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