sw/source/ui/dialog/swdlgfact.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 <config_features.h>
  21 #include <config_fuzzers.h>
  22 #include <config_wasm_strip.h>
  23
  24 #include "swdlgfact.hxx"
  25 #include <svl/style.hxx>
  26 #include <globals.hrc>
  27
  28 #include <wordcountdialog.hxx>
  29 #include <abstract.hxx>
  30 #include <addrdlg.hxx>
  31 #include <ascfldlg.hxx>
  32 #include <bookmark.hxx>
  33 #include <break.hxx>
  34 #include <changedb.hxx>
  35 #include <chrdlg.hxx>
  36 #include <colwd.hxx>
  37 #include <contentcontroldlg.hxx>
  38 #include <contentcontrollistitemdlg.hxx>
  39 #include <pagenumberdlg.hxx>
  40 #include <convert.hxx>
  41 #include <cption.hxx>
  42 #include <dbinsdlg.hxx>
  43 #include <docfnote.hxx>
  44 #include <docstdlg.hxx>
  45 #include <DateFormFieldDialog.hxx>
  46 #include <DropDownFieldDialog.hxx>
  47 #include <DropDownFormFieldDialog.hxx>
  48 #include <envlop.hxx>
  49 #include <label.hxx>
  50 #include <drpcps.hxx>
  51 #include <swuipardlg.hxx>
  52 #include <pattern.hxx>
  53 #include <pardlg.hxx>
  54 #include <rowht.hxx>
  55 #include <selglos.hxx>
  56 #include <splittbl.hxx>
  57 #include <srtdlg.hxx>
  58 #include <tautofmt.hxx>
  59 #include <tblnumfm.hxx>
  60 #include <wrap.hxx>
  61 #include <tabledlg.hxx>
  62 #include <fldtdlg.hxx>
  63 #include <fldedt.hxx>
  64 #include <swrenamexnameddlg.hxx>
  65 #include <swmodalredlineacceptdlg.hxx>
  66 #include <frmdlg.hxx>
  67 #include <tmpdlg.hxx>
  68 #include <glossary.hxx>
  69 #include <inpdlg.hxx>
  70 #include <insfnote.hxx>
  71 #include <instable.hxx>
  72 #include <javaedit.hxx>
  73 #include <linenum.hxx>
  74 #include <titlepage.hxx>
  75 #include <mailmrge.hxx>
  76 #include <mergetbl.hxx>
  77 #include <multmrk.hxx>
  78 #include <num.hxx>
  79 #include <outline.hxx>
  80 #include <column.hxx>
  81 #include <cnttab.hxx>
  82 #include <swuicnttab.hxx>
  83 #include <regionsw.hxx>
  84 #include <optcomp.hxx>
  85 #include <optload.hxx>
  86 #include <optpage.hxx>
  87 #include <swuiidxmrk.hxx>
  88 #include <svx/dialogs.hrc>
  89 #include <mailmergewizard.hxx>
  90 #include <mailconfigpage.hxx>
  91 #include <uiborder.hxx>
  92 #include <mmresultdialogs.hxx>
  93 #include <formatlinebreak.hxx>
  94 #include <translatelangselect.hxx>
  95
  96 using namespace ::com::sun::star;
  97 using namespace css::frame;
  98 using namespace css::uno;
  99
 100 short AbstractSwWordCountFloatDlg_Impl::Execute()
 101 {
 102     return m_xDlg->run();
 103 }
 104
 105 short AbstractSwInsertAbstractDlg_Impl::Execute()
 106 {
 107     return m_xDlg->run();
 108 }
 109
 110 short SwAbstractSfxController_Impl::Execute()
 111 {
 112     return m_xDlg->run();
 113 }
 114
 115 short AbstractNumFormatDlg_Impl::Execute()
 116 {
 117     return m_xDlg->run();
 118 }
 119
 120 bool AbstractNumFormatDlg_Impl::StartExecuteAsync(AsyncContext &rCtx)
 121 {
 122     return SfxSingleTabDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn);
 123 }
 124
 125 short AbstractSwAsciiFilterDlg_Impl::Execute()
 126 {
 127     return m_xDlg->run();
 128 }
 129
 130 short AbstractSplitTableDialog_Impl::Execute()
 131 {
 132     return m_xDlg->run();
 133 }
 134
 135 bool AbstractSplitTableDialog_Impl::StartExecuteAsync(AsyncContext &rCtx)
 136 {
 137     return weld::GenericDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn);
 138 }
 139
 140 short AbstractSwTableWidthDlg_Impl::Execute()
 141 {
 142     return m_xDlg->run();
 143 }
 144
 145 short AbstractSwTableHeightDlg_Impl::Execute()
 146 {
 147     return m_xDlg->run();
 148 }
 149
 150 short AbstractSwMergeTableDlg_Impl::Execute()
 151 {
 152     return m_xDlg->run();
 153 }
 154
 155 short AbstractSwPageNumberDlg_Impl::Execute()
 156 {
 157     return m_xDlg->run();
 158 }
 159
 160 bool AbstractSwPageNumberDlg_Impl::StartExecuteAsync(AsyncContext &rCtx)
 161 {
 162     return weld::GenericDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn);
 163 }
 164
 165 short AbstractGenericDialog_Impl::Execute()
 166 {
 167     return m_xDlg->run();
 168 }
 169
 170 bool AbstractGenericDialog_Impl::StartExecuteAsync(AsyncContext &rCtx)
 171 {
 172     return weld::GenericDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn);
 173 }
 174
 175 short AbstractSwSortDlg_Impl::Execute()
 176 {
 177     return m_xDlg->run();
 178 }
 179
 180 short AbstractMultiTOXMarkDlg_Impl::Execute()
 181 {
 182     return m_xDlg->run();
 183 }
 184
 185 short AbstractTabController_Impl::Execute()
 186 {
 187     return m_xDlg->run();
 188 }
 189
 190 short AbstractSwConvertTableDlg_Impl::Execute()
 191 {
 192     return m_xDlg->run();
 193 }
 194
 195 short AbstractSwInsertDBColAutoPilot_Impl::Execute()
 196 {
 197     return m_xDlg->run();
 198 }
 199
 200 short AbstractDropDownFieldDialog_Impl::Execute()
 201 {
 202     return m_xDlg->run();
 203 }
 204
 205 short AbstractDropDownFormFieldDialog_Impl::Execute()
 206 {
 207     return m_xDlg->run();
 208 }
 209
 210 short AbstractDateFormFieldDialog_Impl::Execute()
 211 {
 212     return m_xDlg->run();
 213 }
 214
 215 short AbstractSwLabDlg_Impl::Execute()
 216 {
 217     return m_xDlg->run();
 218 }
 219
 220 short AbstractSwSelGlossaryDlg_Impl::Execute()
 221 {
 222     return m_xDlg->run();
 223 }
 224
 225 short AbstractSwAutoFormatDlg_Impl::Execute()
 226 {
 227     return m_xDlg->run();
 228 }
 229
 230 short AbstractSwFieldDlg_Impl::Execute()
 231 {
 232     return m_xDlg->run();
 233 }
 234
 235 short AbstractSwRenameXNamedDlg_Impl::Execute()
 236 {
 237     return m_xDlg->run();
 238 }
 239
 240 bool AbstractSwContentControlListItemDlg_Impl::StartExecuteAsync(VclAbstractDialog::AsyncContext& rCtx)
 241 {
 242     return weld::DialogController::runAsync(m_xDlg, rCtx.maEndDialogFn);
 243 }
 244
 245 short AbstractSwContentControlListItemDlg_Impl::Execute()
 246 {
 247     return m_xDlg->run();
 248 }
 249
 250 short AbstractSwModalRedlineAcceptDlg_Impl::Execute()
 251 {
 252     return m_xDlg->run();
 253 }
 254
 255 short AbstractGlossaryDlg_Impl::Execute()
 256 {
 257     return m_xDlg->run();
 258 }
 259
 260 short AbstractFieldInputDlg_Impl::Execute()
 261 {
 262     return m_xDlg->run();
 263 }
 264
 265 short AbstractInsFootNoteDlg_Impl::Execute()
 266 {
 267     return m_xDlg->run();
 268 }
 269
 270 short AbstractJavaEditDialog_Impl::Execute()
 271 {
 272     return m_xDlg->run();
 273 }
 274
 275 short AbstractMailMergeDlg_Impl::Execute()
 276 {
 277     return m_xDlg->run();
 278 }
 279
 280 short AbstractMailMergeCreateFromDlg_Impl::Execute()
 281 {
 282     return m_xDlg->run();
 283 }
 284
 285 short AbstractMailMergeFieldConnectionsDlg_Impl::Execute()
 286 {
 287     return m_xDlg->run();
 288 }
 289
 290 short AbstractMultiTOXTabDialog_Impl::Execute()
 291 {
 292     return m_xDlg->run();
 293 }
 294
 295 bool AbstractMultiTOXTabDialog_Impl::StartExecuteAsync(AsyncContext &rCtx)
 296 {
 297     return SfxTabDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn);
 298 }
 299
 300 short AbstractEditRegionDlg_Impl::Execute()
 301 {
 302     return m_xDlg->run();
 303 }
 304
 305 short AbstractInsertSectionTabDialog_Impl::Execute()
 306 {
 307     return m_xDlg->run();
 308 }
 309
 310 bool AbstractInsertSectionTabDialog_Impl::StartExecuteAsync(AsyncContext &rCtx)
 311 {
 312     return SfxTabDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn);
 313 }
 314
 315 short AbstractIndexMarkFloatDlg_Impl::Execute()
 316 {
 317     return m_xDlg->run();
 318 }
 319
 320 short AbstractAuthMarkFloatDlg_Impl::Execute()
 321 {
 322     return m_xDlg->run();
 323 }
 324
 325 void AbstractTabController_Impl::SetCurPageId( const OUString &rName )
 326 {
 327     m_xDlg->SetCurPageId( rName );
 328 }
 329
 330 const SfxItemSet* AbstractTabController_Impl::GetOutputItemSet() const
 331 {
 332     return m_xDlg->GetOutputItemSet();
 333 }
 334
 335 WhichRangesContainer AbstractTabController_Impl::GetInputRanges(const SfxItemPool& pItem )
 336 {
 337     return m_xDlg->GetInputRanges( pItem );
 338 }
 339
 340 void AbstractTabController_Impl::SetInputSet( const SfxItemSet* pInSet )
 341 {
 342      m_xDlg->SetInputSet( pInSet );
 343 }
 344
 345 bool AbstractTabController_Impl::StartExecuteAsync(AsyncContext &rCtx)
 346 {
 347     return SfxTabDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn);
 348 }
 349
 350 //From class Window.
 351 void AbstractTabController_Impl::SetText( const OUString& rStr )
 352 {
 353     m_xDlg->set_title(rStr);
 354 }
 355
 356 IMPL_LINK_NOARG(AbstractApplyTabController_Impl, ApplyHdl, weld::Button&, void)
 357 {
 358     if (m_xDlg->Apply())
 359     {
 360         m_aHandler.Call(nullptr);
 361         m_xDlg->Applied();
 362     }
 363 }
 364
 365 void AbstractApplyTabController_Impl::SetApplyHdl( const Link<LinkParamNone*,void>& rLink )
 366 {
 367     m_aHandler = rLink;
 368     m_xDlg->SetApplyHandler(LINK(this, AbstractApplyTabController_Impl, ApplyHdl));
 369 }
 370
 371 sal_uInt8 AbstractSwInsertAbstractDlg_Impl::GetLevel() const
 372 {
 373     return m_xDlg->GetLevel();
 374 }
 375
 376 sal_uInt8 AbstractSwInsertAbstractDlg_Impl::GetPara() const
 377 {
 378     return m_xDlg->GetPara();
 379 }
 380
 381 const SfxItemSet* SwAbstractSfxController_Impl::GetOutputItemSet() const
 382 {
 383     return m_xDlg->GetOutputItemSet();
 384 }
 385
 386 const SfxItemSet* AbstractNumFormatDlg_Impl::GetOutputItemSet() const
 387 {
 388     return m_xDlg->GetOutputItemSet();
 389 }
 390
 391 void SwAbstractSfxController_Impl::SetText(const OUString& rStr)
 392 {
 393     m_xDlg->set_title(rStr);
 394 }
 395
 396 void AbstractNumFormatDlg_Impl::SetText(const OUString& rStr)
 397 {
 398     m_xDlg->set_title(rStr);
 399 }
 400
 401 void AbstractSwAsciiFilterDlg_Impl::FillOptions( SwAsciiOptions& rOptions )
 402 {
 403     m_xDlg->FillOptions(rOptions);
 404 }
 405
 406 SplitTable_HeadlineOption AbstractSplitTableDialog_Impl::GetSplitMode()
 407 {
 408     return m_xDlg->GetSplitMode();
 409 }
 410
 411 OUString AbstractSwBreakDlg_Impl::GetTemplateName()
 412 {
 413     SwBreakDlg* pDlg = dynamic_cast<SwBreakDlg*>(m_xDlg.get());
 414     if (pDlg)
 415         return pDlg->GetTemplateName();
 416
 417     return "";
 418 }
 419
 420 sal_uInt16 AbstractSwBreakDlg_Impl:: GetKind()
 421 {
 422     SwBreakDlg* pDlg = dynamic_cast<SwBreakDlg*>(m_xDlg.get());
 423     if (pDlg)
 424         return pDlg->GetKind();
 425
 426     return 0;
 427 }
 428
 429 ::std::optional<sal_uInt16> AbstractSwBreakDlg_Impl:: GetPageNumber()
 430 {
 431     SwBreakDlg* pDlg = dynamic_cast<SwBreakDlg*>(m_xDlg.get());
 432     if (pDlg)
 433         return pDlg->GetPageNumber();
 434
 435     return 0;
 436 }
 437
 438 std::optional<SwLineBreakClear> AbstractSwBreakDlg_Impl::GetClear()
 439 {
 440     SwBreakDlg* pDlg = dynamic_cast<SwBreakDlg*>(m_xDlg.get());
 441     if (pDlg)
 442         return pDlg->GetClear();
 443
 444     return SwLineBreakClear::NONE;
 445 }
 446
 447 void AbstractSwConvertTableDlg_Impl::GetValues( sal_Unicode& rDelim,SwInsertTableOptions& rInsTableFlags,
 448                                                 SwTableAutoFormat const*& prTAFormat)
 449 {
 450     m_xDlg->GetValues(rDelim,rInsTableFlags, prTAFormat);
 451 }
 452
 453 void AbstractSwInsertDBColAutoPilot_Impl::DataToDoc( const uno::Sequence< uno::Any >& rSelection,
 454         uno::Reference< sdbc::XDataSource> rxSource,
 455         uno::Reference< sdbc::XConnection> xConnection,
 456         uno::Reference< sdbc::XResultSet > xResultSet)
 457 {
 458 #if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
 459     m_xDlg->DataToDoc(rSelection, rxSource, xConnection, xResultSet);
 460 #else
 461     (void) rSelection;
 462     (void) rxSource;
 463     (void) xConnection;
 464     (void) xResultSet;
 465 #endif
 466 }
 467
 468 bool AbstractDropDownFieldDialog_Impl::PrevButtonPressed() const
 469 {
 470     return m_xDlg->PrevButtonPressed();
 471 }
 472
 473 bool AbstractDropDownFieldDialog_Impl::NextButtonPressed() const
 474 {
 475     return m_xDlg->NextButtonPressed();
 476 }
 477
 478 void AbstractSwLabDlg_Impl::SetCurPageId( const OUString &rName )
 479 {
 480     m_xDlg->SetCurPageId( rName );
 481 }
 482
 483 const SfxItemSet* AbstractSwLabDlg_Impl::GetOutputItemSet() const
 484 {
 485     return m_xDlg->GetOutputItemSet();
 486 }
 487
 488 WhichRangesContainer AbstractSwLabDlg_Impl::GetInputRanges(const SfxItemPool& pItem )
 489 {
 490     return m_xDlg->GetInputRanges( pItem );
 491 }
 492
 493 void AbstractSwLabDlg_Impl::SetInputSet( const SfxItemSet* pInSet )
 494 {
 495      m_xDlg->SetInputSet( pInSet );
 496 }
 497
 498 void AbstractSwLabDlg_Impl::SetText( const OUString& rStr )
 499 {
 500     m_xDlg->set_title(rStr);
 501 }
 502
 503 const OUString& AbstractSwLabDlg_Impl::GetBusinessCardStr() const
 504 {
 505     return m_xDlg->GetBusinessCardStr();
 506 }
 507
 508 Printer * AbstractSwLabDlg_Impl::GetPrt()
 509 {
 510     return m_xDlg->GetPrt();
 511 }
 512
 513 void AbstractSwSelGlossaryDlg_Impl::InsertGlos(const OUString &rRegion, const OUString &rGlosName)
 514 {
 515     m_xDlg->InsertGlos( rRegion, rGlosName );
 516 }
 517
 518 sal_Int32 AbstractSwSelGlossaryDlg_Impl::GetSelectedIdx() const
 519 {
 520     return m_xDlg->GetSelectedIdx();
 521 }
 522
 523 void AbstractSwSelGlossaryDlg_Impl::SelectEntryPos(sal_Int32 nIdx)
 524 {
 525     m_xDlg->SelectEntryPos( nIdx );
 526 }
 527
 528 std::unique_ptr<SwTableAutoFormat> AbstractSwAutoFormatDlg_Impl::FillAutoFormatOfIndex() const
 529 {
 530     return m_xDlg->FillAutoFormatOfIndex();
 531 }
 532
 533 void AbstractSwFieldDlg_Impl::SetCurPageId( const OUString &rName )
 534 {
 535     m_xDlg->SetCurPageId( rName );
 536 }
 537
 538 const SfxItemSet* AbstractSwFieldDlg_Impl::GetOutputItemSet() const
 539 {
 540     return m_xDlg->GetOutputItemSet();
 541 }
 542
 543 WhichRangesContainer AbstractSwFieldDlg_Impl::GetInputRanges(const SfxItemPool& pItem )
 544 {
 545     return m_xDlg->GetInputRanges( pItem );
 546 }
 547
 548 void AbstractSwFieldDlg_Impl::SetInputSet( const SfxItemSet* pInSet )
 549 {
 550      m_xDlg->SetInputSet( pInSet );
 551 }
 552
 553 void AbstractSwFieldDlg_Impl::SetText( const OUString& rStr )
 554 {
 555     m_xDlg->set_title(rStr);
 556 }
 557
 558 bool AbstractSwFieldDlg_Impl::StartExecuteAsync(AsyncContext &rCtx)
 559 {
 560     auto xDlg = m_xDlg;
 561     return SfxTabDialogController::runAsync(m_xDlg, [=](sal_Int32 nResult){
 562         xDlg->Close();
 563         if (rCtx.isSet())
 564             rCtx.maEndDialogFn(nResult);
 565     });
 566 }
 567
 568 void AbstractSwFieldDlg_Impl::Initialize(SfxChildWinInfo *pInfo)
 569 {
 570     m_xDlg->Initialize( pInfo );
 571 }
 572
 573 void AbstractSwFieldDlg_Impl::ReInitDlg()
 574 {
 575     m_xDlg->ReInitDlg();
 576 }
 577
 578 void AbstractSwFieldDlg_Impl::ActivateDatabasePage()
 579 {
 580     m_xDlg->ActivateDatabasePage();
 581 }
 582
 583 void AbstractSwFieldDlg_Impl::ShowReferencePage()
 584 {
 585     m_xDlg->ShowReferencePage();
 586 }
 587
 588 std::shared_ptr<SfxDialogController> AbstractSwFieldDlg_Impl::GetController()
 589 {
 590     return m_xDlg;
 591 }
 592
 593 void AbstractSwRenameXNamedDlg_Impl::SetForbiddenChars( const OUString& rSet )
 594 {
 595     m_xDlg->SetForbiddenChars( rSet );
 596 }
 597
 598 void    AbstractSwRenameXNamedDlg_Impl::SetAlternativeAccess(
 599              css::uno::Reference< css::container::XNameAccess > & xSecond,
 600              css::uno::Reference< css::container::XNameAccess > & xThird )
 601 {
 602     m_xDlg->SetAlternativeAccess( xSecond, xThird);
 603 }
 604
 605 OUString AbstractGlossaryDlg_Impl::GetCurrGrpName() const
 606 {
 607     return m_xDlg->GetCurrGrpName();
 608 }
 609
 610 OUString AbstractGlossaryDlg_Impl::GetCurrShortName() const
 611 {
 612     return m_xDlg->GetCurrShortName();
 613 }
 614
 615 void AbstractFieldInputDlg_Impl::EndDialog(sal_Int32 n)
 616 {
 617     m_xDlg->response(n);
 618 }
 619
 620 bool AbstractFieldInputDlg_Impl::PrevButtonPressed() const
 621 {
 622     return m_xDlg->PrevButtonPressed();
 623 }
 624
 625 bool AbstractFieldInputDlg_Impl::NextButtonPressed() const
 626 {
 627     return m_xDlg->NextButtonPressed();
 628 }
 629
 630 OUString AbstractInsFootNoteDlg_Impl::GetFontName()
 631 {
 632     return m_xDlg->GetFontName();
 633 }
 634
 635 int AbstractSwPageNumberDlg_Impl::GetPageNumberPosition() const
 636 {
 637     return m_xDlg->GetPageNumberPosition();
 638 }
 639
 640 int AbstractSwPageNumberDlg_Impl::GetPageNumberAlignment() const
 641 {
 642     return m_xDlg->GetPageNumberAlignment();
 643 }
 644
 645 bool AbstractSwPageNumberDlg_Impl::GetMirrorOnEvenPages() const
 646 {
 647     return m_xDlg->GetMirrorOnEvenPages();
 648 }
 649
 650 bool AbstractSwPageNumberDlg_Impl::GetIncludePageTotal() const
 651 {
 652     return m_xDlg->GetIncludePageTotal();
 653 }
 654
 655 SvxNumType AbstractSwPageNumberDlg_Impl::GetPageNumberType() const
 656 {
 657     return m_xDlg->GetPageNumberType();
 658 }
 659
 660 void AbstractSwPageNumberDlg_Impl::SetPageNumberType(SvxNumType nSet)
 661 {
 662     m_xDlg->SetPageNumberType(nSet);
 663 }
 664
 665 bool AbstractInsFootNoteDlg_Impl::IsEndNote()
 666 {
 667     return m_xDlg->IsEndNote();
 668 }
 669
 670 OUString AbstractInsFootNoteDlg_Impl::GetStr()
 671 {
 672     return m_xDlg->GetStr();
 673 }
 674
 675 void AbstractInsFootNoteDlg_Impl::SetHelpId(const OUString& rHelpId)
 676 {
 677     m_xDlg->set_help_id(rHelpId);
 678 }
 679
 680 void AbstractInsFootNoteDlg_Impl::SetText( const OUString& rStr )
 681 {
 682     m_xDlg->set_title(rStr);
 683 }
 684
 685 void AbstractInsTableDlg_Impl::GetValues( OUString& rName, sal_uInt16& rRow, sal_uInt16& rCol,
 686                                 SwInsertTableOptions& rInsTableFlags, OUString& rTableAutoFormatName,
 687                                 std::unique_ptr<SwTableAutoFormat>& prTAFormat )
 688 {
 689     SwInsTableDlg* pDlg = dynamic_cast<SwInsTableDlg*>(m_xDlg.get());
 690     if (pDlg)
 691         pDlg->GetValues(rName, rRow, rCol, rInsTableFlags, rTableAutoFormatName, prTAFormat);
 692 }
 693
 694 OUString AbstractJavaEditDialog_Impl::GetScriptText() const
 695 {
 696     return m_xDlg->GetScriptText();
 697 }
 698
 699 OUString AbstractJavaEditDialog_Impl::GetScriptType() const
 700 {
 701     return m_xDlg->GetScriptType();
 702 }
 703
 704 bool AbstractJavaEditDialog_Impl::IsUrl() const
 705 {
 706     return m_xDlg->IsUrl();
 707 }
 708
 709 bool AbstractJavaEditDialog_Impl::IsNew() const
 710 {
 711     return m_xDlg->IsNew();
 712 }
 713
 714 bool AbstractJavaEditDialog_Impl::IsUpdate() const
 715 {
 716     return m_xDlg->IsUpdate();
 717 }
 718
 719 DBManagerOptions AbstractMailMergeDlg_Impl::GetMergeType()
 720 {
 721     return m_xDlg->GetMergeType();
 722 }
 723
 724 const OUString& AbstractMailMergeDlg_Impl::GetSaveFilter() const
 725 {
 726     return m_xDlg->GetSaveFilter();
 727 }
 728
 729 css::uno::Sequence< css::uno::Any > AbstractMailMergeDlg_Impl::GetSelection() const
 730 {
 731     return m_xDlg->GetSelection();
 732 }
 733
 734 uno::Reference< sdbc::XResultSet> AbstractMailMergeDlg_Impl::GetResultSet() const
 735 {
 736     return m_xDlg->GetResultSet();
 737 }
 738
 739 bool AbstractMailMergeDlg_Impl::IsSaveSingleDoc() const
 740 {
 741     return m_xDlg->IsSaveSingleDoc();
 742 }
 743
 744 bool AbstractMailMergeDlg_Impl::IsGenerateFromDataBase() const
 745 {
 746     return m_xDlg->IsGenerateFromDataBase();
 747 }
 748
 749 bool AbstractMailMergeDlg_Impl::IsFileEncryptedFromDataBase() const
 750 {
 751     return m_xDlg->IsFileEncryptedFromDataBase();
 752 }
 753
 754 OUString AbstractMailMergeDlg_Impl::GetColumnName() const
 755 {
 756     return m_xDlg->GetColumnName();
 757 }
 758
 759 OUString AbstractMailMergeDlg_Impl::GetPasswordColumnName() const
 760 {
 761     return m_xDlg->GetPasswordColumnName();
 762 }
 763
 764 OUString AbstractMailMergeDlg_Impl::GetTargetURL() const
 765 {
 766     return m_xDlg->GetTargetURL();
 767 }
 768
 769 bool AbstractMailMergeCreateFromDlg_Impl::IsThisDocument() const
 770 {
 771     return m_xDlg->IsThisDocument();
 772 }
 773
 774 bool AbstractMailMergeFieldConnectionsDlg_Impl::IsUseExistingConnections() const
 775 {
 776     return m_xDlg->IsUseExistingConnections();
 777 }
 778
 779 CurTOXType AbstractMultiTOXTabDialog_Impl::GetCurrentTOXType() const
 780 {
 781     return m_xDlg->GetCurrentTOXType();
 782 }
 783
 784 SwTOXDescription& AbstractMultiTOXTabDialog_Impl::GetTOXDescription(CurTOXType eTOXTypes)
 785 {
 786     return m_xDlg->GetTOXDescription(eTOXTypes);
 787 }
 788
 789 const SfxItemSet* AbstractMultiTOXTabDialog_Impl::GetOutputItemSet() const
 790 {
 791     return m_xDlg->GetOutputItemSet();
 792 }
 793
 794 void AbstractEditRegionDlg_Impl::SelectSection(const OUString& rSectionName)
 795 {
 796     m_xDlg->SelectSection(rSectionName);
 797 }
 798
 799 void
 800 AbstractInsertSectionTabDialog_Impl::SetSectionData(SwSectionData const& rSect)
 801 {
 802     m_xDlg->SetSectionData(rSect);
 803 }
 804
 805 void AbstractIndexMarkFloatDlg_Impl::ReInitDlg(SwWrtShell& rWrtShell)
 806 {
 807     m_xDlg->ReInitDlg( rWrtShell);
 808 }
 809
 810 std::shared_ptr<SfxDialogController> AbstractIndexMarkFloatDlg_Impl::GetController()
 811 {
 812     return m_xDlg;
 813 }
 814
 815 void AbstractAuthMarkFloatDlg_Impl::ReInitDlg(SwWrtShell& rWrtShell)
 816 {
 817     m_xDlg->ReInitDlg(rWrtShell);
 818 }
 819
 820 std::shared_ptr<SfxDialogController> AbstractAuthMarkFloatDlg_Impl::GetController()
 821 {
 822     return m_xDlg;
 823 }
 824
 825 std::shared_ptr<SfxDialogController> AbstractSwWordCountFloatDlg_Impl::GetController()
 826 {
 827     return m_xDlg;
 828 }
 829
 830 void AbstractSwWordCountFloatDlg_Impl::UpdateCounts()
 831 {
 832     m_xDlg->UpdateCounts();
 833 }
 834
 835 void AbstractSwWordCountFloatDlg_Impl::SetCounts(const SwDocStat &rCurrCnt, const SwDocStat &rDocStat)
 836 {
 837     m_xDlg->SetCounts(rCurrCnt, rDocStat);
 838 }
 839
 840 AbstractMailMergeWizard_Impl::~AbstractMailMergeWizard_Impl()
 841 {
 842 }
 843
 844 bool AbstractMailMergeWizard_Impl::StartExecuteAsync(AsyncContext &rCtx)
 845 {
 846     // SwMailMergeWizardExecutor wants to run the lifecycle of this dialog
 847     // so clear mxOwner here and leave it up to SwMailMergeWizardExecutor
 848     rCtx.mxOwner.clear();
 849     return weld::GenericDialogController::runAsync(m_xDlg, rCtx.maEndDialogFn);
 850 }
 851
 852 short AbstractMailMergeWizard_Impl::Execute()
 853 {
 854     return m_xDlg->run();
 855 }
 856
 857 OUString AbstractMailMergeWizard_Impl::GetReloadDocument() const
 858 {
 859     return m_xDlg->GetReloadDocument();
 860 }
 861
 862 void AbstractMailMergeWizard_Impl::ShowPage( sal_uInt16 nLevel )
 863 {
 864     m_xDlg->skipUntil(nLevel);
 865 }
 866
 867 sal_uInt16 AbstractMailMergeWizard_Impl::GetRestartPage() const
 868 {
 869     return m_xDlg->GetRestartPage();
 870 }
 871
 872 std::optional<SwLanguageListItem> AbstractSwTranslateLangSelectDlg_Impl::GetSelectedLanguage()
 873 {
 874 #if !ENABLE_WASM_STRIP_EXTRA
 875     return SwTranslateLangSelectDlg::GetSelectedLanguage();
 876 #else
 877     return {};
 878 #endif
 879 }
 880
 881 VclPtr<AbstractSwInsertAbstractDlg> SwAbstractDialogFactory_Impl::CreateSwInsertAbstractDlg(weld::Window* pParent)
 882 {
 883     return VclPtr<AbstractSwInsertAbstractDlg_Impl>::Create(std::make_unique<SwInsertAbstractDlg>(pParent));
 884 }
 885
 886 VclPtr<SfxAbstractDialog> SwAbstractDialogFactory_Impl::CreateSwAddressAbstractDlg(weld::Window* pParent,
 887                                                                   const SfxItemSet& rSet)
 888 {
 889     return VclPtr<SwAbstractSfxController_Impl>::Create(std::make_unique<SwAddrDlg>(pParent, rSet));
 890 }
 891
 892 VclPtr<SfxAbstractDialog> SwAbstractDialogFactory_Impl::CreateSwDropCapsDialog(weld::Window* pParent,
 893                                                                   const SfxItemSet& rSet)
 894 {
 895     return VclPtr<SwAbstractSfxController_Impl>::Create(std::make_unique<SwDropCapsDlg>(pParent, rSet));
 896 }
 897
 898 VclPtr<SfxAbstractDialog> SwAbstractDialogFactory_Impl::CreateSwBackgroundDialog(weld::Window* pParent,
 899                                                                   const SfxItemSet& rSet)
 900 {
 901     return VclPtr<SwAbstractSfxController_Impl>::Create(std::make_unique<SwBackgroundDlg>(pParent, rSet));
 902 }
 903
 904 VclPtr<SfxAbstractDialog> SwAbstractDialogFactory_Impl::CreateNumFormatDialog(weld::Widget* pParent, const SfxItemSet& rSet)
 905 {
 906     return VclPtr<AbstractNumFormatDlg_Impl>::Create(std::make_shared<SwNumFormatDlg>(pParent, rSet));
 907 }
 908
 909 VclPtr<AbstractSwAsciiFilterDlg> SwAbstractDialogFactory_Impl::CreateSwAsciiFilterDlg(weld::Window* pParent,
 910        SwDocShell& rDocSh, SvStream* pStream)
 911 {
 912     return VclPtr<AbstractSwAsciiFilterDlg_Impl>::Create(std::make_unique<SwAsciiFilterDlg>(pParent, rDocSh, pStream));
 913 }
 914
 915 VclPtr<VclAbstractDialog> SwAbstractDialogFactory_Impl::CreateSwInsertBookmarkDlg(weld::Window *pParent,
 916         SwWrtShell &rSh, OUString const*const pSelected)
 917 {
 918     return VclPtr<AbstractGenericDialog_Impl>::Create(std::make_shared<SwInsertBookmarkDlg>(pParent, rSh, pSelected));
 919 }
 920
 921 VclPtr<VclAbstractDialog> SwAbstractDialogFactory_Impl::CreateSwContentControlDlg(weld::Window* pParent,
 922                                                                                   SwWrtShell &rSh)
 923 {
 924     return VclPtr<AbstractGenericDialog_Impl>::Create(std::make_shared<SwContentControlDlg>(pParent, rSh));
 925 }
 926
 927 VclPtr<AbstractSwContentControlListItemDlg>
 928 SwAbstractDialogFactory_Impl::CreateSwContentControlListItemDlg(weld::Window* pParent,
 929                                                                 SwContentControlListItem& rItem)
 930 {
 931     return VclPtr<AbstractSwContentControlListItemDlg_Impl>::Create(
 932         std::make_shared<SwContentControlListItemDlg>(pParent, rItem));
 933 }
 934
 935 std::shared_ptr<AbstractSwBreakDlg> SwAbstractDialogFactory_Impl::CreateSwBreakDlg(weld::Window* pParent, SwWrtShell &rSh)
 936 {
 937     return std::make_shared<AbstractSwBreakDlg_Impl>(std::make_unique<SwBreakDlg>(pParent, rSh));
 938 }
 939
 940 std::shared_ptr<AbstractSwTranslateLangSelectDlg> SwAbstractDialogFactory_Impl::CreateSwTranslateLangSelectDlg(weld::Window* pParent, SwWrtShell &rSh)
 941 {
 942 #if !ENABLE_WASM_STRIP_EXTRA
 943     return std::make_shared<AbstractSwTranslateLangSelectDlg_Impl>(std::make_unique<SwTranslateLangSelectDlg>(pParent, rSh));
 944 #else
 945     (void) pParent;
 946     (void) rSh;
 947     return nullptr;
 948 #endif
 949 }
 950
 951 VclPtr<VclAbstractDialog> SwAbstractDialogFactory_Impl::CreateSwChangeDBDlg(SwView& rVw)
 952 {
 953 #if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
 954     return VclPtr<AbstractGenericDialog_Impl>::Create(std::make_shared<SwChangeDBDlg>(rVw));
 955 #else
 956     (void) rVw;
 957     return nullptr;
 958 #endif
 959 }
 960
 961 VclPtr<SfxAbstractTabDialog>  SwAbstractDialogFactory_Impl::CreateSwCharDlg(weld::Window* pParent, SwView& pVw,
 962     const SfxItemSet& rCoreSet, SwCharDlgMode nDialogMode, const OUString* pFormatStr)
 963 {
 964     return VclPtr<AbstractTabController_Impl>::Create(std::make_shared<SwCharDlg>(pParent, pVw, rCoreSet, nDialogMode, pFormatStr));
 965 }
 966
 967 VclPtr<AbstractSwConvertTableDlg> SwAbstractDialogFactory_Impl::CreateSwConvertTableDlg(SwView& rView, bool bToTable)
 968 {
 969     return VclPtr<AbstractSwConvertTableDlg_Impl>::Create(std::make_unique<SwConvertTableDlg>(rView, bToTable));
 970 }
 971
 972 VclPtr<VclAbstractDialog> SwAbstractDialogFactory_Impl::CreateSwCaptionDialog(weld::Window *pParent, SwView &rV)
 973 {
 974     return VclPtr<AbstractGenericDialog_Impl>::Create(std::make_shared<SwCaptionDialog>(pParent, rV));
 975 }
 976
 977 VclPtr<AbstractSwInsertDBColAutoPilot> SwAbstractDialogFactory_Impl::CreateSwInsertDBColAutoPilot( SwView& rView,
 978         uno::Reference< sdbc::XDataSource> rxSource,
 979         uno::Reference<sdbcx::XColumnsSupplier> xColSupp,
 980         const SwDBData& rData)
 981 {
 982 #if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
 983     return VclPtr<AbstractSwInsertDBColAutoPilot_Impl>::Create(std::make_unique<SwInsertDBColAutoPilot>(rView, rxSource, xColSupp, rData));
 984 #else
 985     (void) rView;
 986     (void) rxSource;
 987     (void) xColSupp;
 988     (void) rData;
 989     return nullptr;
 990 #endif
 991 }
 992
 993 VclPtr<SfxAbstractTabDialog> SwAbstractDialogFactory_Impl::CreateSwFootNoteOptionDlg(weld::Window *pParent, SwWrtShell &rSh)
 994 {
 995     return VclPtr<AbstractTabController_Impl>::Create(std::make_shared<SwFootNoteOptionDlg>(pParent, rSh));
 996 }
 997
 998 VclPtr<AbstractDropDownFieldDialog> SwAbstractDialogFactory_Impl::CreateDropDownFieldDialog(weld::Widget *pParent,
 999     SwWrtShell &rSh, SwField* pField, bool bPrevButton, bool bNextButton)
1000 {
1001     return VclPtr<AbstractDropDownFieldDialog_Impl>::Create(std::make_unique<sw::DropDownFieldDialog>(pParent, rSh, pField, bPrevButton, bNextButton));
1002 }
1003
1004 VclPtr<VclAbstractDialog> SwAbstractDialogFactory_Impl::CreateDropDownFormFieldDialog(weld::Widget *pParent, sw::mark::IFieldmark* pDropDownField)
1005 {
1006     return VclPtr<AbstractDropDownFormFieldDialog_Impl>::Create(std::make_unique<sw::DropDownFormFieldDialog>(pParent, pDropDownField));
1007 }
1008
1009 VclPtr<VclAbstractDialog> SwAbstractDialogFactory_Impl::CreateDateFormFieldDialog(weld::Widget *pParent, sw::mark::IDateFieldmark* pDateField, SwDoc& rDoc)
1010 {
1011     return VclPtr<AbstractDateFormFieldDialog_Impl>::Create(std::make_unique<sw::DateFormFieldDialog>(pParent, pDateField, rDoc));
1012 }
1013
1014 VclPtr<SfxAbstractTabDialog> SwAbstractDialogFactory_Impl::CreateSwEnvDlg(weld::Window* pParent, const SfxItemSet& rSet,
1015                                                                  SwWrtShell* pWrtSh, Printer* pPrt,
1016                                                                  bool bInsert)
1017 {
1018     return VclPtr<AbstractTabController_Impl>::Create(std::make_shared<SwEnvDlg>(pParent, rSet, pWrtSh,pPrt, bInsert));
1019 }
1020
1021 VclPtr<AbstractSwLabDlg> SwAbstractDialogFactory_Impl::CreateSwLabDlg(weld::Window* pParent, const SfxItemSet& rSet,
1022                                                      SwDBManager* pDBManager, bool bLabel)
1023 {
1024     return VclPtr<AbstractSwLabDlg_Impl>::Create(std::make_unique<SwLabDlg>(pParent, rSet, pDBManager, bLabel));
1025 }
1026
1027 SwLabDlgMethod SwAbstractDialogFactory_Impl::GetSwLabDlgStaticMethod ()
1028 {
1029     return SwLabDlg::UpdateFieldInformation;
1030 }
1031
1032 VclPtr<SfxAbstractTabDialog> SwAbstractDialogFactory_Impl::CreateSwParaDlg(weld::Window *pParent, SwView& rVw,
1033                                                                            const SfxItemSet& rCoreSet,
1034                                                                            bool bDraw ,
1035                                                                            const OUString& sDefPage)
1036 {
1037     return VclPtr<AbstractTabController_Impl>::Create(std::make_shared<SwParaDlg>(pParent, rVw, rCoreSet, DLG_STD, nullptr, bDraw, sDefPage));
1038 }
1039
1040 VclPtr<VclAbstractDialog> SwAbstractDialogFactory_Impl::CreateSwAutoMarkDialog(weld::Window *pParent, SwWrtShell &rSh)
1041 {
1042     return VclPtr<AbstractGenericDialog_Impl>::Create(std::make_shared<SwAuthMarkModalDlg>(pParent, rSh));
1043 }
1044
1045 VclPtr<VclAbstractDialog> SwAbstractDialogFactory_Impl::CreateSwColumnDialog(weld::Window *pParent, SwWrtShell &rSh)
1046 {
1047     return VclPtr<AbstractGenericDialog_Impl>::Create(std::make_shared<SwColumnDlg>(pParent, rSh));
1048 }
1049
1050 VclPtr<VclAbstractDialog> SwAbstractDialogFactory_Impl::CreateSwTableHeightDialog(weld::Window *pParent, SwWrtShell &rSh)
1051 {
1052     return VclPtr<AbstractSwTableHeightDlg_Impl>::Create(std::make_unique<SwTableHeightDlg>(pParent, rSh));
1053 }
1054
1055 VclPtr<VclAbstractDialog> SwAbstractDialogFactory_Impl::CreateSwSortingDialog(weld::Window *pParent, SwWrtShell &rSh)
1056 {
1057     return VclPtr<AbstractSwSortDlg_Impl>::Create(std::make_unique<SwSortDlg>(pParent, rSh));
1058 }
1059
1060 VclPtr<AbstractSplitTableDialog> SwAbstractDialogFactory_Impl::CreateSplitTableDialog(weld::Window *pParent, SwWrtShell &rSh)
1061 {
1062     return VclPtr<AbstractSplitTableDialog_Impl>::Create(std::make_shared<SwSplitTableDlg>(pParent, rSh));
1063 }
1064
1065 VclPtr<AbstractSwSelGlossaryDlg> SwAbstractDialogFactory_Impl::CreateSwSelGlossaryDlg(weld::Window *pParent, const OUString &rShortName)
1066 {
1067     return VclPtr<AbstractSwSelGlossaryDlg_Impl>::Create(std::make_unique<SwSelGlossaryDlg>(pParent, rShortName));
1068 }
1069
1070 VclPtr<AbstractSwAutoFormatDlg> SwAbstractDialogFactory_Impl::CreateSwAutoFormatDlg(weld::Window* pParent,
1071     SwWrtShell* pShell, bool bSetAutoFormat, const SwTableAutoFormat* pSelFormat)
1072 {
1073     return VclPtr<AbstractSwAutoFormatDlg_Impl>::Create(
1074                 std::unique_ptr<SwAutoFormatDlg, o3tl::default_delete<SwAutoFormatDlg>>(
1075                     new SwAutoFormatDlg(pParent, pShell, bSetAutoFormat, pSelFormat)));
1076 }
1077
1078 VclPtr<SfxAbstractDialog> SwAbstractDialogFactory_Impl::CreateSwBorderDlg(weld::Window* pParent, SfxItemSet& rSet, SwBorderModes nType )
1079 {
1080     return VclPtr<SwAbstractSfxController_Impl>::Create(std::make_unique<SwBorderDlg>(pParent, rSet, nType));
1081 }
1082
1083 VclPtr<SfxAbstractDialog> SwAbstractDialogFactory_Impl::CreateSwWrapDlg(weld::Window* pParent, SfxItemSet& rSet, SwWrtShell* pSh)
1084 {
1085     return VclPtr<SwAbstractSfxController_Impl>::Create(std::make_unique<SwWrapDlg>(pParent, rSet, pSh, true/*bDrawMode*/));
1086 }
1087
1088 VclPtr<VclAbstractDialog> SwAbstractDialogFactory_Impl::CreateSwTableWidthDlg(weld::Window *pParent, SwTableFUNC &rFnc)
1089 {
1090     return VclPtr<AbstractSwTableWidthDlg_Impl>::Create(std::make_unique<SwTableWidthDlg>(pParent, rFnc));
1091 }
1092
1093 VclPtr<SfxAbstractTabDialog> SwAbstractDialogFactory_Impl::CreateSwTableTabDlg(weld::Window* pParent,
1094     const SfxItemSet* pItemSet, SwWrtShell* pSh)
1095 {
1096     return VclPtr<AbstractTabController_Impl>::Create(std::make_shared<SwTableTabDlg>(pParent, pItemSet, pSh));
1097 }
1098
1099 VclPtr<AbstractSwFieldDlg> SwAbstractDialogFactory_Impl::CreateSwFieldDlg(SfxBindings* pB, SwChildWinWrapper* pCW, weld::Window *pParent)
1100 {
1101     return VclPtr<AbstractSwFieldDlg_Impl>::Create(std::make_shared<SwFieldDlg>(pB, pCW, pParent));
1102 }
1103
1104 VclPtr<SfxAbstractDialog> SwAbstractDialogFactory_Impl::CreateSwFieldEditDlg(SwView& rVw)
1105 {
1106     return VclPtr<SwAbstractSfxController_Impl>::Create(std::make_unique<SwFieldEditDlg>(rVw));
1107 }
1108
1109 VclPtr<AbstractSwRenameXNamedDlg> SwAbstractDialogFactory_Impl::CreateSwRenameXNamedDlg(weld::Widget* pParent,
1110     css::uno::Reference< css::container::XNamed > & xNamed,
1111     css::uno::Reference< css::container::XNameAccess > & xNameAccess)
1112 {
1113     return VclPtr<AbstractSwRenameXNamedDlg_Impl>::Create(std::make_unique<SwRenameXNamedDlg>(pParent,xNamed, xNameAccess));
1114 }
1115
1116 VclPtr<AbstractSwModalRedlineAcceptDlg> SwAbstractDialogFactory_Impl::CreateSwModalRedlineAcceptDlg(weld::Window *pParent)
1117 {
1118     return VclPtr<AbstractSwModalRedlineAcceptDlg_Impl>::Create(std::make_unique<SwModalRedlineAcceptDlg>(pParent));
1119 }
1120
1121 VclPtr<AbstractSwPageNumberDlg> SwAbstractDialogFactory_Impl::CreateSwPageNumberDlg(weld::Window *pParent)
1122 {
1123     return VclPtr<AbstractSwPageNumberDlg_Impl>::Create(std::make_shared<SwPageNumberDlg>(pParent));
1124 }
1125
1126 VclPtr<VclAbstractDialog> SwAbstractDialogFactory_Impl::CreateTableMergeDialog(weld::Window* pParent, bool& rWithPrev)
1127 {
1128     return VclPtr<AbstractSwMergeTableDlg_Impl>::Create(std::make_unique<SwMergeTableDlg>(pParent, rWithPrev));
1129 }
1130
1131 VclPtr<SfxAbstractTabDialog> SwAbstractDialogFactory_Impl::CreateFrameTabDialog(const OUString &rDialogType,
1132                                                 SfxViewFrame& rFrame, weld::Window *pParent,
1133                                                 const SfxItemSet& rCoreSet,
1134                                                 bool        bNewFrame,
1135                                                 const OUString&  sDefPage )
1136 {
1137     return VclPtr<AbstractTabController_Impl>::Create(std::make_shared<SwFrameDlg>(rFrame, pParent, rCoreSet, bNewFrame, rDialogType, false/*bFormat*/, sDefPage, nullptr));
1138 }
1139
1140 VclPtr<SfxAbstractApplyTabDialog> SwAbstractDialogFactory_Impl::CreateTemplateDialog(
1141                                                 weld::Window *pParent,
1142                                                 SfxStyleSheetBase&  rBase,
1143                                                 SfxStyleFamily      nRegion,
1144                                                 const OUString&     sPage,
1145                                                 SwWrtShell*         pActShell,
1146                                                 bool                bNew )
1147 {
1148     return VclPtr<AbstractApplyTabController_Impl>::Create(std::make_shared<SwTemplateDlgController>(pParent, rBase, nRegion,
1149                                                                                                      sPage, pActShell, bNew));
1150 }
1151
1152 VclPtr<AbstractGlossaryDlg> SwAbstractDialogFactory_Impl::CreateGlossaryDlg(SfxViewFrame& rViewFrame, SwGlossaryHdl* pGlosHdl,
1153                                                                             SwWrtShell *pWrtShell)
1154 {
1155     return VclPtr<AbstractGlossaryDlg_Impl>::Create(std::make_unique<SwGlossaryDlg>(rViewFrame, pGlosHdl, pWrtShell));
1156 }
1157
1158 VclPtr<AbstractFieldInputDlg> SwAbstractDialogFactory_Impl::CreateFieldInputDlg(weld::Widget *pParent,
1159     SwWrtShell &rSh, SwField* pField, bool bPrevButton, bool bNextButton)
1160 {
1161     return VclPtr<AbstractFieldInputDlg_Impl>::Create(std::make_unique<SwFieldInputDlg>(pParent, rSh, pField, bPrevButton, bNextButton));
1162 }
1163
1164 VclPtr<AbstractInsFootNoteDlg> SwAbstractDialogFactory_Impl::CreateInsFootNoteDlg(
1165     weld::Window * pParent, SwWrtShell &rSh, bool bEd )
1166 {
1167     return VclPtr<AbstractInsFootNoteDlg_Impl>::Create(std::make_unique<SwInsFootNoteDlg>(pParent, rSh, bEd));
1168 }
1169
1170 VclPtr<VclAbstractDialog> SwAbstractDialogFactory_Impl::CreateTitlePageDlg(weld::Window *pParent)
1171 {
1172     return VclPtr<AbstractGenericDialog_Impl>::Create(std::make_shared<SwTitlePageDlg>(pParent));
1173 }
1174
1175 VclPtr<VclAbstractDialog> SwAbstractDialogFactory_Impl::CreateVclSwViewDialog(SwView& rView)
1176 {
1177     return VclPtr<AbstractGenericDialog_Impl>::Create(std::make_shared<SwLineNumberingDlg>(rView));
1178 }
1179
1180 std::shared_ptr<AbstractInsTableDlg> SwAbstractDialogFactory_Impl::CreateInsTableDlg(SwView& rView)
1181 {
1182     return std::make_shared<AbstractInsTableDlg_Impl>(std::make_shared<SwInsTableDlg>(rView));
1183 }
1184
1185 VclPtr<AbstractJavaEditDialog> SwAbstractDialogFactory_Impl::CreateJavaEditDialog(
1186     weld::Window* pParent, SwWrtShell* pWrtSh)
1187 {
1188     return VclPtr<AbstractJavaEditDialog_Impl>::Create(std::make_unique<SwJavaEditDialog>(pParent, pWrtSh));
1189 }
1190
1191 VclPtr<AbstractMailMergeDlg> SwAbstractDialogFactory_Impl::CreateMailMergeDlg(
1192                                                 weld::Window* pParent, SwWrtShell& rSh,
1193                                                 const OUString& rSourceName,
1194                                                 const OUString& rTableName,
1195                                                 sal_Int32 nCommandType,
1196                                                 const uno::Reference< sdbc::XConnection>& xConnection )
1197 {
1198     return VclPtr<AbstractMailMergeDlg_Impl>::Create(std::make_unique<SwMailMergeDlg>(pParent, rSh, rSourceName, rTableName, nCommandType, xConnection, nullptr));
1199 }
1200
1201 VclPtr<AbstractMailMergeCreateFromDlg> SwAbstractDialogFactory_Impl::CreateMailMergeCreateFromDlg(weld::Window* pParent)
1202 {
1203     return VclPtr<AbstractMailMergeCreateFromDlg_Impl>::Create(std::make_unique<SwMailMergeCreateFromDlg>(pParent));
1204 }
1205
1206 VclPtr<AbstractMailMergeFieldConnectionsDlg> SwAbstractDialogFactory_Impl::CreateMailMergeFieldConnectionsDlg(weld::Window* pParent)
1207 {
1208     return VclPtr<AbstractMailMergeFieldConnectionsDlg_Impl>::Create(std::make_unique<SwMailMergeFieldConnectionsDlg>(pParent));
1209 }
1210
1211 VclPtr<VclAbstractDialog> SwAbstractDialogFactory_Impl::CreateMultiTOXMarkDlg(weld::Window* pParent, SwTOXMgr &rTOXMgr)
1212 {
1213     return VclPtr<AbstractMultiTOXMarkDlg_Impl>::Create(std::make_unique<SwMultiTOXMarkDlg>(pParent, rTOXMgr));
1214 }
1215
1216 VclPtr<SfxAbstractTabDialog> SwAbstractDialogFactory_Impl::CreateSvxNumBulletTabDialog(weld::Window* pParent,
1217                                                 const SfxItemSet* pSwItemSet,
1218                                                 SwWrtShell & rWrtSh)
1219 {
1220     return VclPtr<AbstractTabController_Impl>::Create(std::make_shared<SwSvxNumBulletTabDialog>(pParent, pSwItemSet, rWrtSh));
1221 }
1222
1223 VclPtr<SfxAbstractTabDialog> SwAbstractDialogFactory_Impl::CreateOutlineTabDialog(weld::Window* pParent,
1224                                                 const SfxItemSet* pSwItemSet,
1225                                                 SwWrtShell & rWrtSh )
1226 {
1227     return VclPtr<AbstractTabController_Impl>::Create(std::make_shared<SwOutlineTabDialog>(pParent, pSwItemSet, rWrtSh));
1228 }
1229
1230 VclPtr<AbstractMultiTOXTabDialog> SwAbstractDialogFactory_Impl::CreateMultiTOXTabDialog(weld::Widget* pParent, const SfxItemSet& rSet,
1231                                                                                         SwWrtShell &rShell, SwTOXBase* pCurTOX, bool bGlobal)
1232 {
1233     return VclPtr<AbstractMultiTOXTabDialog_Impl>::Create(std::make_shared<SwMultiTOXTabDialog>(pParent, rSet, rShell, pCurTOX, USHRT_MAX, bGlobal));
1234 }
1235
1236 VclPtr<AbstractEditRegionDlg> SwAbstractDialogFactory_Impl::CreateEditRegionDlg(weld::Window* pParent, SwWrtShell& rWrtSh)
1237 {
1238     return VclPtr<AbstractEditRegionDlg_Impl>::Create(std::make_shared<SwEditRegionDlg>(pParent, rWrtSh));
1239 }
1240
1241 VclPtr<AbstractInsertSectionTabDialog> SwAbstractDialogFactory_Impl::CreateInsertSectionTabDialog(weld::Window* pParent,
1242         const SfxItemSet& rSet, SwWrtShell& rSh)
1243 {
1244     return VclPtr<AbstractInsertSectionTabDialog_Impl>::Create(std::make_shared<SwInsertSectionTabDialog>(pParent, rSet, rSh));
1245 }
1246
1247 VclPtr<AbstractMarkFloatDlg> SwAbstractDialogFactory_Impl::CreateIndexMarkFloatDlg(
1248                                                        SfxBindings* pBindings,
1249                                                        SfxChildWindow* pChild,
1250                                                        weld::Window *pParent,
1251                                                        SfxChildWinInfo* pInfo )
1252 {
1253     return VclPtr<AbstractIndexMarkFloatDlg_Impl>::Create(std::make_shared<SwIndexMarkFloatDlg>(pBindings, pChild, pParent, pInfo, true/*bNew*/));
1254 }
1255
1256 VclPtr<AbstractMarkFloatDlg> SwAbstractDialogFactory_Impl::CreateAuthMarkFloatDlg(
1257                                                        SfxBindings* pBindings,
1258                                                        SfxChildWindow* pChild,
1259                                                        weld::Window *pParent,
1260                                                        SfxChildWinInfo* pInfo)
1261 {
1262     return VclPtr<AbstractAuthMarkFloatDlg_Impl>::Create(std::make_shared<SwAuthMarkFloatDlg>(pBindings, pChild, pParent, pInfo, true/*bNew*/));
1263 }
1264
1265 VclPtr<AbstractSwWordCountFloatDlg> SwAbstractDialogFactory_Impl::CreateSwWordCountDialog(
1266                                                                               SfxBindings* pBindings,
1267                                                                               SfxChildWindow* pChild,
1268                                                                               weld::Window *pParent,
1269                                                                               SfxChildWinInfo* pInfo)
1270 {
1271     return VclPtr<AbstractSwWordCountFloatDlg_Impl>::Create(std::make_shared<SwWordCountFloatDlg>(pBindings, pChild, pParent, pInfo));
1272 }
1273
1274 VclPtr<VclAbstractDialog> SwAbstractDialogFactory_Impl::CreateIndexMarkModalDlg(weld::Window *pParent, SwWrtShell& rSh, SwTOXMark* pCurTOXMark )
1275 {
1276     return VclPtr<AbstractGenericDialog_Impl>::Create(std::make_shared<SwIndexMarkModalDlg>(pParent, rSh, pCurTOXMark));
1277 }
1278
1279 VclPtr<AbstractMailMergeWizard> SwAbstractDialogFactory_Impl::CreateMailMergeWizard(
1280                                     SwView& rView, std::shared_ptr<SwMailMergeConfigItem>& rConfigItem)
1281 {
1282 #if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
1283     return VclPtr<AbstractMailMergeWizard_Impl>::Create(std::make_shared<SwMailMergeWizard>(rView, rConfigItem));
1284 #else
1285     (void) rView;
1286     (void) rConfigItem;
1287     return nullptr;
1288 #endif
1289 }
1290
1291 GlossaryGetCurrGroup    SwAbstractDialogFactory_Impl::GetGlossaryCurrGroupFunc()
1292 {
1293     return SwGlossaryDlg::GetCurrGroup;
1294 }
1295
1296 GlossarySetActGroup SwAbstractDialogFactory_Impl::SetGlossaryActGroupFunc()
1297 {
1298     return SwGlossaryDlg::SetActGroup;
1299 }
1300
1301 // Factories for TabPages
1302 CreateTabPage SwAbstractDialogFactory_Impl::GetTabPageCreatorFunc( sal_uInt16 nId )
1303 {
1304     CreateTabPage pRet = nullptr;
1305     switch ( nId )
1306     {
1307         case RID_SW_TP_OPTCOMPATIBILITY_PAGE :
1308             pRet = SwCompatibilityOptPage::Create;
1309             break;
1310         case RID_SW_TP_OPTLOAD_PAGE :
1311             pRet = SwLoadOptPage::Create;
1312             break;
1313         case RID_SW_TP_OPTCAPTION_PAGE:
1314             return SwCaptionOptPage::Create;
1315         case RID_SW_TP_CONTENT_OPT:
1316         case RID_SW_TP_HTML_CONTENT_OPT:
1317             pRet = SwContentOptPage::Create;
1318             break;
1319         case RID_SW_TP_OPTSHDWCRSR:
1320         case RID_SW_TP_HTML_OPTSHDWCRSR:
1321             pRet = SwShdwCursorOptionsTabPage::Create;
1322             break;
1323         case RID_SW_TP_REDLINE_OPT :
1324             pRet = SwRedlineOptionsTabPage::Create;
1325             break;
1326         case RID_SW_TP_OPTTEST_PAGE :
1327 #ifdef DBG_UTIL
1328             pRet = SwTestTabPage::Create;
1329 #endif
1330             break;
1331         case TP_OPTPRINT_PAGE :
1332         case RID_SW_TP_HTML_OPTPRINT_PAGE:
1333         case RID_SW_TP_OPTPRINT_PAGE:
1334             pRet = SwAddPrinterTabPage::Create;
1335             break;
1336         case RID_SW_TP_STD_FONT:
1337         case RID_SW_TP_STD_FONT_CJK:
1338         case RID_SW_TP_STD_FONT_CTL:
1339             pRet = SwStdFontTabPage::Create;
1340             break;
1341         case RID_SW_TP_HTML_OPTTABLE_PAGE:
1342         case RID_SW_TP_OPTTABLE_PAGE:
1343             pRet = SwTableOptionsTabPage::Create;
1344             break;
1345         case RID_SW_TP_DOC_STAT :
1346             pRet = SwDocStatPage::Create;
1347             break;
1348         case RID_SW_TP_MAILCONFIG:
1349             pRet = SwMailConfigPage::Create;
1350         break;
1351         case RID_SW_TP_COMPARISON_OPT :
1352             pRet = SwCompareOptionsTabPage::Create;
1353         break;
1354     }
1355
1356     return pRet;
1357 }
1358
1359 void SwAbstractDialogFactory_Impl::ExecuteMMResultSaveDialog(weld::Window* pParent)
1360 {
1361 #if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
1362     SwMMResultSaveDialog aDialog(pParent);
1363     aDialog.run();
1364 #else
1365     (void) pParent;
1366 #endif
1367 }
1368
1369 void SwAbstractDialogFactory_Impl::ExecuteMMResultPrintDialog(weld::Window* pParent)
1370 {
1371 #if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
1372     SwMMResultPrintDialog aDialog(pParent);
1373     aDialog.run();
1374 #else
1375     (void) pParent;
1376 #endif
1377 }
1378
1379 void SwAbstractDialogFactory_Impl::ExecuteMMResultEmailDialog(weld::Window* pParent)
1380 {
1381 #if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
1382     SwMMResultEmailDialog aDialog(pParent);
1383     aDialog.run();
1384 #else
1385     (void) pParent;
1386 #endif
1387 }
1388
1389 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */