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