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