sfx2/source/dialog/tabdlg.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: tabdlg.cxx,v $
  10  * $Revision: 1.38 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sfx2.hxx"
  33
  34 #include <limits.h>
  35 #include <stdlib.h>
  36 #include <vcl/msgbox.hxx>
  37 #include <svtools/viewoptions.hxx>
  38
  39 #define _SVSTDARR_USHORTS
  40 #include <svtools/svstdarr.hxx>
  41
  42 #include "appdata.hxx"
  43 #include "sfxtypes.hxx"
  44 #include <sfx2/minarray.hxx>
  45 #include <sfx2/tabdlg.hxx>
  46 #include <sfx2/viewfrm.hxx>
  47 #include <sfx2/app.hxx>
  48 #include "sfxresid.hxx"
  49 #include "sfxhelp.hxx"
  50 #include <sfx2/ctrlitem.hxx>
  51 #include <sfx2/bindings.hxx>
  52 #include <sfx2/sfxdlg.hxx>
  53 #include <sfx2/itemconnect.hxx>
  54
  55 #include "dialog.hrc"
  56 #include "helpid.hrc"
  57
  58 #if ENABLE_LAYOUT_SFX_TABDIALOG
  59 #undef TabPage
  60 #undef SfxTabPage
  61 #define SfxTabPage ::SfxTabPage
  62 #undef SfxTabDialog
  63 #endif /* ENABLE_LAYOUT_SFX_TABDIALOG */
  64
  65 using namespace ::com::sun::star::uno;
  66 using namespace ::rtl;
  67
  68 #define USERITEM_NAME                   OUString::createFromAscii( "UserItem" )
  69
  70 TYPEINIT1(LAYOUT_NS_SFX_TABDIALOG SfxTabDialogItem,SfxSetItem);
  71
  72 struct TabPageImpl
  73 {
  74     BOOL                        mbStandard;
  75     sfx::ItemConnectionArray    maItemConn;
  76     ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame > mxFrame;
  77
  78     TabPageImpl() : mbStandard( FALSE ) {}
  79 };
  80
  81 NAMESPACE_LAYOUT_SFX_TABDIALOG
  82
  83 struct Data_Impl
  84 {
  85     USHORT nId;                                  // Die ID
  86     CreateTabPage fnCreatePage;  // Pointer auf die Factory
  87     GetTabPageRanges fnGetRanges;// Pointer auf die Ranges-Funktion
  88     SfxTabPage* pTabPage;                // die TabPage selber
  89     BOOL bOnDemand;                              // Flag: ItemSet onDemand
  90     BOOL bRefresh;                               // Flag: Seite mu\s neu initialisiert werden
  91
  92     // Konstruktor
  93     Data_Impl( USHORT Id, CreateTabPage fnPage,
  94                GetTabPageRanges fnRanges, BOOL bDemand ) :
  95
  96         nId                     ( Id ),
  97         fnCreatePage( fnPage ),
  98         fnGetRanges     ( fnRanges ),
  99         pTabPage        ( 0 ),
 100         bOnDemand       ( bDemand ),
 101         bRefresh        ( FALSE )
 102     {
 103         if ( !fnCreatePage  )
 104         {
 105             SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();
 106             if ( pFact )
 107             {
 108                 fnCreatePage = pFact->GetTabPageCreatorFunc( nId );
 109                 fnGetRanges = pFact->GetTabPageRangesFunc( nId );
 110             }
 111         }
 112     }
 113 };
 114
 115 SfxTabDialogItem::SfxTabDialogItem( const SfxTabDialogItem& rAttr, SfxItemPool* pItemPool )
 116     : SfxSetItem( rAttr, pItemPool )
 117 {
 118 }
 119
 120 SfxTabDialogItem::SfxTabDialogItem( USHORT nId, const SfxItemSet& rItemSet )
 121     : SfxSetItem( nId, rItemSet )
 122 {
 123 }
 124
 125 SfxPoolItem* __EXPORT SfxTabDialogItem::Clone(SfxItemPool* pToPool) const
 126 {
 127     return new SfxTabDialogItem( *this, pToPool );
 128 }
 129
 130 SfxPoolItem* __EXPORT SfxTabDialogItem::Create(SvStream& /*rStream*/, USHORT /*nVersion*/) const
 131 {
 132     DBG_ERROR( "Use it only in UI!" );
 133     return NULL;
 134 }
 135
 136 class SfxTabDialogController : public SfxControllerItem
 137 {
 138     SfxTabDialog*   pDialog;
 139     const SfxItemSet*     pSet;
 140 public:
 141                     SfxTabDialogController( USHORT nSlotId, SfxBindings& rBindings, SfxTabDialog* pDlg )
 142                         : SfxControllerItem( nSlotId, rBindings )
 143                         , pDialog( pDlg )
 144                         , pSet( NULL )
 145                     {}
 146
 147                     ~SfxTabDialogController();
 148
 149     DECL_LINK(      Execute_Impl, void* );
 150     virtual void    StateChanged( USHORT nSID, SfxItemState eState, const SfxPoolItem* pState );
 151 };
 152
 153 SfxTabDialogController::~SfxTabDialogController()
 154 {
 155     delete pSet;
 156 }
 157
 158 IMPL_LINK( SfxTabDialogController, Execute_Impl, void*, pVoid )
 159 {
 160     (void)pVoid; //unused
 161     if ( pDialog->OK_Impl() && pDialog->Ok() )
 162     {
 163         const SfxPoolItem* aItems[2];
 164         SfxTabDialogItem aItem( GetId(), *pDialog->GetOutputItemSet() );
 165         aItems[0] = &aItem;
 166         aItems[1] = NULL;
 167         GetBindings().Execute( GetId(), aItems );
 168     }
 169
 170     return 0;
 171 }
 172
 173 void SfxTabDialogController::StateChanged( USHORT /*nSID*/, SfxItemState /*eState*/, const SfxPoolItem* pState )
 174 {
 175     const SfxSetItem* pSetItem = PTR_CAST( SfxSetItem, pState );
 176     if ( pSetItem )
 177     {
 178         pSet = pDialog->pSet = pSetItem->GetItemSet().Clone();
 179         BOOL bDialogStarted = FALSE;
 180         for ( USHORT n=0; n<pDialog->aTabCtrl.GetPageCount(); n++ )
 181         {
 182             USHORT nPageId = pDialog->aTabCtrl.GetPageId( n );
 183             SfxTabPage* pTabPage = dynamic_cast<SfxTabPage*> (pDialog->aTabCtrl.GetTabPage( nPageId ));
 184             if ( pTabPage )
 185             {
 186                 pTabPage->Reset( pSetItem->GetItemSet() );
 187                 bDialogStarted = TRUE;
 188             }
 189         }
 190
 191         if ( bDialogStarted )
 192             pDialog->Show();
 193     }
 194     else
 195         pDialog->Hide();
 196 }
 197
 198 DECL_PTRARRAY(SfxTabDlgData_Impl, Data_Impl *, 4,4)
 199
 200 struct TabDlg_Impl
 201 {
 202     BOOL                                bModified               : 1,
 203                         bModal                  : 1,
 204                         bInOK                   : 1,
 205                         bHideResetBtn   : 1;
 206     SfxTabDlgData_Impl* pData;
 207
 208     PushButton*                 pApplyButton;
 209     SfxTabDialogController* pController;
 210
 211     TabDlg_Impl( BYTE nCnt ) :
 212
 213         bModified               ( FALSE ),
 214         bModal                  ( TRUE ),
 215         bInOK                   ( FALSE ),
 216         bHideResetBtn   ( FALSE ),
 217         pData                   ( new SfxTabDlgData_Impl( nCnt ) ),
 218         pApplyButton    ( NULL ),
 219         pController     ( NULL )
 220     {}
 221 };
 222
 223 Data_Impl* Find( SfxTabDlgData_Impl& rArr, USHORT nId, USHORT* pPos = 0 );
 224
 225 Data_Impl* Find( SfxTabDlgData_Impl& rArr, USHORT nId, USHORT* pPos )
 226 {
 227     const USHORT nCount = rArr.Count();
 228
 229     for ( USHORT i = 0; i < nCount; ++i )
 230     {
 231         Data_Impl* pObj = rArr[i];
 232
 233         if ( pObj->nId == nId )
 234         {
 235             if ( pPos )
 236                 *pPos = i;
 237             return pObj;
 238         }
 239     }
 240     return 0;
 241 }
 242
 243 #if !ENABLE_LAYOUT_SFX_TABDIALOG
 244
 245 void SfxTabPage::SetFrame(const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& xFrame)
 246 {
 247     if (pImpl)
 248         pImpl->mxFrame = xFrame;
 249 }
 250
 251 ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame > SfxTabPage::GetFrame()
 252 {
 253     if (pImpl)
 254         return pImpl->mxFrame;
 255     return ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >();
 256 }
 257
 258 SfxTabPage::SfxTabPage( Window *pParent,
 259                         const ResId &rResId, const SfxItemSet &rAttrSet ) :
 260
 261 /*  [Beschreibung]
 262
 263     Konstruktor
 264 */
 265
 266     TabPage( pParent, rResId ),
 267
 268     pSet                                ( &rAttrSet ),
 269     bHasExchangeSupport ( FALSE ),
 270     pTabDlg                             ( NULL ),
 271     pImpl                               ( new TabPageImpl )
 272
 273 {
 274 }
 275 // -----------------------------------------------------------------------
 276 SfxTabPage:: SfxTabPage( Window *pParent, WinBits nStyle, const SfxItemSet &rAttrSet ) :
 277     TabPage(pParent, nStyle),
 278     pSet                                ( &rAttrSet ),
 279     bHasExchangeSupport ( FALSE ),
 280     pTabDlg                             ( NULL ),
 281     pImpl                               ( new TabPageImpl )
 282 {
 283 }
 284 // -----------------------------------------------------------------------
 285
 286 SfxTabPage::~SfxTabPage()
 287
 288 /*  [Beschreibung]
 289
 290     Destruktor
 291 */
 292
 293 {
 294 #if !ENABLE_LAYOUT
 295     delete pImpl;
 296 #endif /* ENABLE_LAYOUT */
 297 }
 298
 299 // -----------------------------------------------------------------------
 300
 301 BOOL SfxTabPage::FillItemSet( SfxItemSet& rSet )
 302 {
 303     return pImpl->maItemConn.DoFillItemSet( rSet, GetItemSet() );
 304 }
 305
 306 // -----------------------------------------------------------------------
 307
 308 void SfxTabPage::Reset( const SfxItemSet& rSet )
 309 {
 310     pImpl->maItemConn.DoApplyFlags( rSet );
 311     pImpl->maItemConn.DoReset( rSet );
 312 }
 313
 314 // -----------------------------------------------------------------------
 315
 316 void SfxTabPage::ActivatePage( const SfxItemSet& )
 317
 318 /*  [Beschreibung]
 319
 320     Defaultimplementierung der virtuellen ActivatePage-Methode
 321     Diese wird gerufen, wenn eine Seite des Dialogs den Datenaustausch
 322     zwischen Pages unterst"utzt.
 323
 324     <SfxTabPage::DeactivatePage(SfxItemSet *)>
 325 */
 326
 327 {
 328 }
 329
 330 // -----------------------------------------------------------------------
 331
 332 int SfxTabPage::DeactivatePage( SfxItemSet* )
 333
 334 /*  [Beschreibung]
 335
 336     Defaultimplementierung der virtuellen DeactivatePage-Methode
 337     Diese wird vor dem Verlassen einer Seite durch den Sfx gerufen;
 338     die Anwendung kann "uber den Returnwert steuern,
 339     ob die Seite verlassen werden soll.
 340     Falls die Seite "uber bHasExchangeSupport
 341     anzeigt, da\s sie einen Datenaustausch zwischen Seiten
 342     unterst"utzt, wird ein Pointer auf das Austausch-Set als
 343     Parameter "ubergeben. Dieser nimmt die Daten f"ur den Austausch
 344     entgegen; das Set steht anschlie\send als Parameter in
 345     <SfxTabPage::ActivatePage(const SfxItemSet &)> zur Verf"ugung.
 346
 347     [R"uckgabewert]
 348
 349     LEAVE_PAGE; Verlassen der Seite erlauben
 350 */
 351
 352 {
 353     return LEAVE_PAGE;
 354 }
 355
 356 // -----------------------------------------------------------------------
 357
 358 void SfxTabPage::FillUserData()
 359
 360 /*  [Beschreibung]
 361
 362    virtuelle Methode, wird von der Basisklasse im Destruktor gerufen
 363    um spezielle Informationen der TabPage in der Ini-Datei zu speichern.
 364    Beim "Uberladen muss ein String zusammengestellt werden, der mit
 365    <SetUserData()> dann weggeschrieben wird.
 366 */
 367
 368 {
 369 }
 370
 371 // -----------------------------------------------------------------------
 372
 373 BOOL SfxTabPage::IsReadOnly() const
 374
 375 /*  [Description]
 376
 377 */
 378
 379 {
 380     return FALSE;
 381 }
 382
 383 // -----------------------------------------------------------------------
 384
 385 const SfxPoolItem* SfxTabPage::GetItem( const SfxItemSet& rSet, USHORT nSlot, sal_Bool bDeep )
 386
 387 /*  [Beschreibung]
 388
 389     static Methode: hiermit wird der Code der TabPage-Implementierungen
 390     vereinfacht.
 391
 392 */
 393
 394 {
 395     const SfxItemPool* pPool = rSet.GetPool();
 396     USHORT nWh = pPool->GetWhich( nSlot, bDeep );
 397     const SfxPoolItem* pItem = 0;
 398 #ifdef DEBUG
 399     SfxItemState eState;
 400     eState =
 401 #endif
 402             rSet.GetItemState( nWh, TRUE, &pItem );  // -Wall required??
 403
 404     if ( !pItem && nWh != nSlot )
 405         pItem = &pPool->GetDefaultItem( nWh );
 406     return pItem;
 407 }
 408
 409 // -----------------------------------------------------------------------
 410
 411 const SfxPoolItem* SfxTabPage::GetOldItem( const SfxItemSet& rSet,
 412                                            USHORT nSlot, sal_Bool bDeep )
 413
 414 /*  [Beschreibung]
 415
 416     Diese Methode gibt f"ur Vergleiche den alten Wert eines
 417     Attributs zur"uck.
 418 */
 419
 420 {
 421     const SfxItemSet& rOldSet = GetItemSet();
 422     USHORT nWh = GetWhich( nSlot, bDeep );
 423     const SfxPoolItem* pItem = 0;
 424
 425     if ( pImpl->mbStandard && rOldSet.GetParent() )
 426         pItem = GetItem( *rOldSet.GetParent(), nSlot );
 427     else if ( rSet.GetParent() &&
 428               SFX_ITEM_DONTCARE == rSet.GetItemState( nWh ) )
 429         pItem = GetItem( *rSet.GetParent(), nSlot );
 430     else
 431         pItem = GetItem( rOldSet, nSlot );
 432     return pItem;
 433 }
 434
 435 // -----------------------------------------------------------------------
 436
 437 const SfxPoolItem* SfxTabPage::GetExchangeItem( const SfxItemSet& rSet,
 438                                                 USHORT nSlot )
 439
 440 /*  [Beschreibung]
 441
 442     Diese Methode gibt f"ur Vergleiche den alten Wert eines
 443     Attributs zur"uck. Dabei wird ber"ucksichtigt, ob der Dialog
 444     gerade mit OK beendet wurde.
 445 */
 446
 447 {
 448     if ( pTabDlg && !pTabDlg->IsInOK() && pTabDlg->GetExampleSet() )
 449         return GetItem( *pTabDlg->GetExampleSet(), nSlot );
 450     else
 451         return GetOldItem( rSet, nSlot );
 452 }
 453
 454 // add CHINA001  begin
 455 void SfxTabPage::PageCreated( SfxAllItemSet /*aSet*/ )
 456 {
 457     DBG_ASSERT(0, "SfxTabPage::PageCreated should not be called");
 458 }//CHINA001
 459 // add CHINA001 end
 460
 461 // -----------------------------------------------------------------------
 462
 463 void SfxTabPage::AddItemConnection( sfx::ItemConnectionBase* pConnection )
 464 {
 465     pImpl->maItemConn.AddConnection( pConnection );
 466 }
 467
 468 #endif /* !ENABLE_LAYOUT_SFX_TABDIALOG */
 469
 470 #if ENABLE_LAYOUT_SFX_TABDIALOG
 471 #undef ResId
 472 #define ResId(id, foo) #id
 473 #undef TabDialog
 474 #define TabDialog(parent, res_id) Dialog (parent, "tab-dialog.xml", "tab-dialog")
 475
 476 #define aOKBtn(this) aOKBtn (this, "BTN_OK")
 477 #undef PushButton
 478 #define PushButton(this) layout::PushButton (this, "BTN_USER")
 479 #define aCancelBtn(this) aCancelBtn (this, "BTN_CANCEL")
 480 #define aHelpBtn(this) aHelpBtn (this, "BTN_HELP")
 481 #define aResetBtn(this) aResetBtn (this, "BTN_RESET")
 482 #define aBaseFmtBtn(this) aBaseFmtBtn (this, "BTN_BASEFMT")
 483 #endif /* ENABLE_LAYOUT_SFX_TABDIALOG */
 484
 485 #define INI_LIST(ItemSetPtr) \
 486     aTabCtrl    ( this, ResId(ID_TABCONTROL,*rResId.GetResMgr() ) ),\
 487     aOKBtn              ( this ),\
 488     pUserBtn    ( pUserButtonText? new PushButton(this): 0 ),\
 489     aCancelBtn  ( this ),\
 490     aHelpBtn    ( this ),\
 491     aResetBtn   ( this ),\
 492     aBaseFmtBtn ( this ),\
 493     pSet        ( ItemSetPtr ),\
 494     pOutSet             ( 0 ),\
 495     pImpl               ( new TabDlg_Impl( (BYTE)aTabCtrl.GetPageCount() ) ), \
 496     pRanges             ( 0 ), \
 497     nResId              ( rResId.GetId() ), \
 498     nAppPageId  ( USHRT_MAX ), \
 499     bItemsReset ( FALSE ),\
 500     bFmt                ( bEditFmt ),\
 501     pExampleSet ( 0 )
 502
 503 // -----------------------------------------------------------------------
 504
 505 SfxTabDialog::SfxTabDialog
 506
 507 /*  [Beschreibung]
 508
 509     Konstruktor
 510 */
 511
 512 (
 513     SfxViewFrame* pViewFrame,           // Frame, zu dem der Dialog geh"ort
 514     Window* pParent,                            // Parent-Fenster
 515     const ResId& rResId,                        // ResourceId
 516     const SfxItemSet* pItemSet,         // Itemset mit den Daten;
 517                                     // kann NULL sein, wenn Pages onDemand
 518     BOOL bEditFmt,              // Flag: es werden Vorlagen bearbeitet
 519                         // wenn ja -> zus"atzlicher Button f"ur Standard
 520     const String* pUserButtonText       // Text fuer BenutzerButton;
 521                                     // wenn != 0, wird der UserButton erzeugt
 522 ) :
 523     TabDialog( pParent, rResId ),
 524     pFrame( pViewFrame ),
 525     INI_LIST(pItemSet)
 526 {
 527     Init_Impl( bFmt, pUserButtonText );
 528 }
 529
 530 // -----------------------------------------------------------------------
 531
 532 SfxTabDialog::SfxTabDialog
 533
 534 /*  [Beschreibung]
 535
 536     Konstruktor, tempor"ar ohne Frame
 537 */
 538
 539 (
 540     Window* pParent,                            // Parent-Fenster
 541     const ResId& rResId,                        // ResourceId
 542     const SfxItemSet* pItemSet,         // Itemset mit den Daten; kann NULL sein,
 543                                     // wenn Pages onDemand
 544     BOOL bEditFmt,              // Flag: es werden Vorlagen bearbeitet
 545                         // wenn ja -> zus"atzlicher Button f"ur Standard
 546     const String* pUserButtonText       // Text f"ur BenutzerButton;
 547                                     // wenn != 0, wird der UserButton erzeugt
 548 ) :
 549     TabDialog( pParent, rResId ),
 550     pFrame( 0 ),
 551     INI_LIST(pItemSet)
 552 {
 553     Init_Impl( bFmt, pUserButtonText );
 554     DBG_WARNING( "bitte den Ctor mit ViewFrame verwenden" );
 555 }
 556
 557 SfxTabDialog::SfxTabDialog
 558
 559 /*  [Beschreibung]
 560
 561     Konstruktor, tempor"ar ohne Frame
 562 */
 563
 564 (
 565     Window* pParent,                            // Parent-Fenster
 566     const ResId& rResId,                        // ResourceId
 567     USHORT nSetId,
 568     SfxBindings& rBindings,
 569     BOOL bEditFmt,              // Flag: es werden Vorlagen bearbeitet
 570                         // wenn ja -> zus"atzlicher Button f"ur Standard
 571     const String* pUserButtonText       // Text f"ur BenutzerButton;
 572                                     // wenn != 0, wird der UserButton erzeugt
 573 ) :
 574     TabDialog( pParent, rResId ),
 575     pFrame( 0 ),
 576     INI_LIST(NULL)
 577 {
 578     rBindings.ENTERREGISTRATIONS();
 579     pImpl->pController = new SfxTabDialogController( nSetId, rBindings, this );
 580     rBindings.LEAVEREGISTRATIONS();
 581
 582     EnableApplyButton( TRUE );
 583     SetApplyHandler( LINK( pImpl->pController, SfxTabDialogController, Execute_Impl ) );
 584
 585     rBindings.Invalidate( nSetId );
 586     rBindings.Update( nSetId );
 587     DBG_ASSERT( pSet, "No ItemSet!" );
 588
 589     Init_Impl( bFmt, pUserButtonText );
 590 }
 591
 592 // -----------------------------------------------------------------------
 593
 594 #if ENABLE_LAYOUT_SFX_TABDIALOG
 595 #undef ResId
 596 #undef TabDialog
 597 #undef aOKBtn
 598 #undef PushButton
 599 #undef aCancelBtn
 600 #undef aHelpBtn
 601 #undef aResetBtn
 602 #undef aBaseFmtBtn
 603 #endif /* ENABLE_LAYOUT_SFX_TABDIALOG */
 604
 605 SfxTabDialog::~SfxTabDialog()
 606 {
 607     // save settings (screen position and current page)
 608     SvtViewOptions aDlgOpt( E_TABDIALOG, String::CreateFromInt32( nResId ) );
 609 #if !ENABLE_LAYOUT_SFX_TABDIALOG
 610     aDlgOpt.SetWindowState( OUString::createFromAscii( GetWindowState( WINDOWSTATE_MASK_POS ).GetBuffer() ) );
 611 #endif /* !ENABLE_LAYOUT_SFX_TABDIALOG */
 612     aDlgOpt.SetPageID( aTabCtrl.GetCurPageId() );
 613
 614     const USHORT nCount = pImpl->pData->Count();
 615     for ( USHORT i = 0; i < nCount; ++i )
 616     {
 617         Data_Impl* pDataObject = pImpl->pData->GetObject(i);
 618
 619         if ( pDataObject->pTabPage )
 620         {
 621             // save settings of all pages (user data)
 622             pDataObject->pTabPage->FillUserData();
 623             String aPageData( pDataObject->pTabPage->GetUserData() );
 624             if ( aPageData.Len() )
 625             {
 626                 // save settings of all pages (user data)
 627                 SvtViewOptions aPageOpt( E_TABPAGE, String::CreateFromInt32( pDataObject->nId ) );
 628                 aPageOpt.SetUserItem( USERITEM_NAME, makeAny( OUString( aPageData ) ) );
 629             }
 630
 631             if ( pDataObject->bOnDemand )
 632                 delete (SfxItemSet*)&pDataObject->pTabPage->GetItemSet();
 633             delete pDataObject->pTabPage;
 634         }
 635         delete pDataObject;
 636     }
 637
 638     delete pImpl->pController;
 639     delete pImpl->pApplyButton;
 640     delete pImpl->pData;
 641     delete pImpl;
 642     delete pUserBtn;
 643     delete pOutSet;
 644     delete pExampleSet;
 645     delete [] pRanges;
 646 }
 647
 648 // -----------------------------------------------------------------------
 649
 650 void SfxTabDialog::Init_Impl( BOOL bFmtFlag, const String* pUserButtonText )
 651
 652 /*  [Beschreibung]
 653
 654     interne Initialisierung des Dialogs
 655 */
 656
 657 {
 658     aOKBtn.SetClickHdl( LINK( this, SfxTabDialog, OkHdl ) );
 659     aResetBtn.SetClickHdl( LINK( this, SfxTabDialog, ResetHdl ) );
 660     aResetBtn.SetText( String( SfxResId( STR_RESET ) ) );
 661     aTabCtrl.SetActivatePageHdl(
 662             LINK( this, SfxTabDialog, ActivatePageHdl ) );
 663     aTabCtrl.SetDeactivatePageHdl(
 664             LINK( this, SfxTabDialog, DeactivatePageHdl ) );
 665     aTabCtrl.Show();
 666     aOKBtn.Show();
 667     aCancelBtn.Show();
 668     aHelpBtn.Show();
 669     aResetBtn.Show();
 670     aResetBtn.SetHelpId( HID_TABDLG_RESET_BTN );
 671
 672     if ( pUserBtn )
 673     {
 674         pUserBtn->SetText( *pUserButtonText );
 675         pUserBtn->SetClickHdl( LINK( this, SfxTabDialog, UserHdl ) );
 676         pUserBtn->Show();
 677     }
 678
 679     /* TODO: Check what is up with bFmt/bFmtFlag. Comment below suggests a
 680              different behavior than implemented!! */
 681     if ( bFmtFlag )
 682     {
 683         String aStd( SfxResId( STR_STANDARD_SHORTCUT ) );
 684         aBaseFmtBtn.SetText( aStd );
 685         aBaseFmtBtn.SetClickHdl( LINK( this, SfxTabDialog, BaseFmtHdl ) );
 686         aBaseFmtBtn.SetHelpId( HID_TABDLG_STANDARD_BTN );
 687
 688         // bFmt = tempor"ares Flag im Ctor() "ubergeben,
 689         // wenn bFmt == 2, dann auch TRUE,
 690         // zus"atzlich Ausblendung vom StandardButton,
 691         // nach der Initialisierung wieder auf TRUE setzen
 692         if ( bFmtFlag != 2 )
 693             aBaseFmtBtn.Show();
 694         else
 695             bFmtFlag = TRUE;
 696     }
 697
 698     if ( pSet )
 699     {
 700         pExampleSet = new SfxItemSet( *pSet );
 701         pOutSet = new SfxItemSet( *pSet->GetPool(), pSet->GetRanges() );
 702     }
 703 }
 704
 705 // -----------------------------------------------------------------------
 706
 707 void SfxTabDialog::RemoveResetButton()
 708 {
 709     aResetBtn.Hide();
 710     pImpl->bHideResetBtn = TRUE;
 711 }
 712
 713 // -----------------------------------------------------------------------
 714
 715 #if ENABLE_LAYOUT_SFX_TABDIALOG
 716 #undef TabDialog
 717 #define TabDialog Dialog
 718 #endif /* ENABLE_LAYOUT_SFX_TABDIALOG */
 719
 720 short SfxTabDialog::Execute()
 721 {
 722     if ( !aTabCtrl.GetPageCount() )
 723         return RET_CANCEL;
 724     Start_Impl();
 725     return TabDialog::Execute();
 726 }
 727
 728 // -----------------------------------------------------------------------
 729
 730 void SfxTabDialog::StartExecuteModal( const Link& rEndDialogHdl )
 731 {
 732 #if !ENABLE_LAYOUT_SFX_TABDIALOG
 733     if ( !aTabCtrl.GetPageCount() )
 734         return;
 735     Start_Impl();
 736     TabDialog::StartExecuteModal( rEndDialogHdl );
 737 #else
 738     rEndDialogHdl.IsSet();
 739 #endif /* !ENABLE_LAYOUT_SFX_TABDIALOG */
 740 }
 741
 742 // -----------------------------------------------------------------------
 743
 744 void SfxTabDialog::Start( BOOL bShow )
 745 {
 746     aCancelBtn.SetClickHdl( LINK( this, SfxTabDialog, CancelHdl ) );
 747     pImpl->bModal = FALSE;
 748     Start_Impl();
 749
 750     if ( bShow )
 751         Show();
 752 }
 753
 754 // -----------------------------------------------------------------------
 755
 756 void SfxTabDialog::SetApplyHandler(const Link& _rHdl)
 757 {
 758     DBG_ASSERT( pImpl->pApplyButton, "SfxTabDialog::GetApplyHandler: no apply button enabled!" );
 759     if ( pImpl->pApplyButton )
 760         pImpl->pApplyButton->SetClickHdl( _rHdl );
 761 }
 762
 763 // -----------------------------------------------------------------------
 764
 765 Link SfxTabDialog::GetApplyHandler() const
 766 {
 767     DBG_ASSERT( pImpl->pApplyButton, "SfxTabDialog::GetApplyHandler: no button enabled!" );
 768     if ( !pImpl->pApplyButton )
 769         return Link();
 770
 771     return pImpl->pApplyButton->GetClickHdl();
 772 }
 773
 774 // -----------------------------------------------------------------------
 775
 776 void SfxTabDialog::EnableApplyButton(BOOL bEnable)
 777 {
 778     if ( IsApplyButtonEnabled() == bEnable )
 779         // nothing to do
 780         return;
 781
 782     // create or remove the apply button
 783     if ( bEnable )
 784     {
 785         pImpl->pApplyButton = new PushButton( this );
 786 #if !ENABLE_LAYOUT_SFX_TABDIALOG
 787         // in the z-order, the apply button should be behind the ok button, thus appearing at the right side of it
 788         pImpl->pApplyButton->SetZOrder(&aOKBtn, WINDOW_ZORDER_BEHIND);
 789 #endif /* ENABLE_LAYOUT_SFX_TABDIALOG */
 790         pImpl->pApplyButton->SetText( String( SfxResId( STR_APPLY ) ) );
 791         pImpl->pApplyButton->Show();
 792
 793         pImpl->pApplyButton->SetHelpId( HID_TABDLG_APPLY_BTN );
 794     }
 795     else
 796     {
 797         delete pImpl->pApplyButton;
 798         pImpl->pApplyButton = NULL;
 799     }
 800
 801 #if !ENABLE_LAYOUT_SFX_TABDIALOG
 802     // adjust the layout
 803     if (IsReallyShown())
 804         AdjustLayout();
 805 #endif /* !ENABLE_LAYOUT_SFX_TABDIALOG */
 806 }
 807
 808 // -----------------------------------------------------------------------
 809
 810 BOOL SfxTabDialog::IsApplyButtonEnabled() const
 811 {
 812     return ( NULL != pImpl->pApplyButton );
 813 }
 814
 815 // -----------------------------------------------------------------------
 816
 817 const PushButton* SfxTabDialog::GetApplyButton() const
 818 {
 819     return pImpl->pApplyButton;
 820 }
 821
 822 // -----------------------------------------------------------------------
 823
 824 PushButton* SfxTabDialog::GetApplyButton()
 825 {
 826     return pImpl->pApplyButton;
 827 }
 828
 829 // -----------------------------------------------------------------------
 830
 831 void SfxTabDialog::Start_Impl()
 832 {
 833     DBG_ASSERT( pImpl->pData->Count() == aTabCtrl.GetPageCount(), "not all pages registered" );
 834     USHORT nActPage = aTabCtrl.GetPageId( 0 );
 835
 836     // load old settings, when exists
 837     SvtViewOptions aDlgOpt( E_TABDIALOG, String::CreateFromInt32( nResId ) );
 838     if ( aDlgOpt.Exists() )
 839     {
 840 #if !ENABLE_LAYOUT_SFX_TABDIALOG
 841         SetWindowState( ByteString( aDlgOpt.GetWindowState().getStr(), RTL_TEXTENCODING_ASCII_US ) );
 842 #endif /* !ENABLE_LAYOUT_SFX_TABDIALOG */
 843
 844         // initiale TabPage aus Programm/Hilfe/Konfig
 845         nActPage = (USHORT)aDlgOpt.GetPageID();
 846
 847         if ( USHRT_MAX != nAppPageId )
 848             nActPage = nAppPageId;
 849         else
 850         {
 851             USHORT nAutoTabPageId = SFX_APP()->Get_Impl()->nAutoTabPageId;
 852             if ( nAutoTabPageId )
 853                 nActPage = nAutoTabPageId;
 854         }
 855
 856         if ( TAB_PAGE_NOTFOUND == aTabCtrl.GetPagePos( nActPage ) )
 857             nActPage = aTabCtrl.GetPageId( 0 );
 858     }
 859     else if ( USHRT_MAX != nAppPageId && TAB_PAGE_NOTFOUND != aTabCtrl.GetPagePos( nAppPageId ) )
 860         nActPage = nAppPageId;
 861
 862     aTabCtrl.SetCurPageId( nActPage );
 863     ActivatePageHdl( &aTabCtrl );
 864 }
 865
 866 void SfxTabDialog::AddTabPage( USHORT nId, BOOL bItemsOnDemand )
 867 {
 868     AddTabPage( nId, 0, 0, bItemsOnDemand );
 869 }
 870
 871 void SfxTabDialog::AddTabPage( USHORT nId, const String &rRiderText, BOOL bItemsOnDemand, USHORT nPos )
 872 {
 873     AddTabPage( nId, rRiderText, 0, 0, bItemsOnDemand, nPos );
 874 }
 875
 876 #ifdef SV_HAS_RIDERBITMAPS
 877
 878 void SfxTabDialog::AddTabPage( USHORT nId, const Bitmap &rRiderBitmap, BOOL bItemsOnDemand, USHORT nPos )
 879 {
 880     AddTabPage( nId, rRiderBitmap, 0, 0, bItemsOnDemand, nPos );
 881 }
 882
 883 #endif
 884
 885 // -----------------------------------------------------------------------
 886
 887 void SfxTabDialog::AddTabPage
 888
 889 /*  [Beschreibung]
 890
 891     Hinzuf"ugen einer Seite zu dem Dialog.
 892     Mu\s korrespondieren zu einem entsprechende Eintrag im
 893     TabControl in der Resource des Dialogs.
 894 */
 895
 896 (
 897     USHORT nId,                                         // ID der Seite
 898     CreateTabPage pCreateFunc,          // Pointer auf die Factory-Methode
 899     GetTabPageRanges pRangesFunc,       // Pointer auf die Methode f"ur das
 900                                     // Erfragen der Ranges onDemand
 901     BOOL bItemsOnDemand                         // gibt an, ob das Set dieser Seite beim
 902                                     // Erzeugen der Seite erfragt wird
 903 )
 904 {
 905     pImpl->pData->Append(
 906         new Data_Impl( nId, pCreateFunc, pRangesFunc, bItemsOnDemand ) );
 907 }
 908
 909 // -----------------------------------------------------------------------
 910
 911 void SfxTabDialog::AddTabPage
 912
 913 /*  [Beschreibung]
 914
 915     Hinzuf"ugen einer Seite zu dem Dialog.
 916     Der Ridertext wird "ubergeben, die Seite hat keine Entsprechung im
 917     TabControl in der Resource des Dialogs.
 918 */
 919
 920 (
 921     USHORT nId,
 922     const String& rRiderText,
 923     CreateTabPage pCreateFunc,
 924     GetTabPageRanges pRangesFunc,
 925     BOOL bItemsOnDemand,
 926     USHORT nPos
 927 )
 928 {
 929     DBG_ASSERT( TAB_PAGE_NOTFOUND == aTabCtrl.GetPagePos( nId ),
 930                 "Doppelte Page-Ids in der Tabpage" );
 931     aTabCtrl.InsertPage( nId, rRiderText, nPos );
 932     pImpl->pData->Append(
 933         new Data_Impl( nId, pCreateFunc, pRangesFunc, bItemsOnDemand ) );
 934 }
 935
 936 // -----------------------------------------------------------------------
 937 #ifdef SV_HAS_RIDERBITMAPS
 938
 939 void SfxTabDialog::AddTabPage
 940
 941 /*  [Beschreibung]
 942
 943     Hinzuf"ugen einer Seite zu dem Dialog.
 944     Die Riderbitmap wird "ubergeben, die Seite hat keine Entsprechung im
 945     TabControl in der Resource des Dialogs.
 946 */
 947
 948 (
 949     USHORT nId,
 950     const Bitmap &rRiderBitmap,
 951     CreateTabPage pCreateFunc,
 952     GetTabPageRanges pRangesFunc,
 953     BOOL bItemsOnDemand,
 954     USHORT nPos
 955 )
 956 {
 957     DBG_ASSERT( TAB_PAGE_NOTFOUND == aTabCtrl.GetPagePos( nId ),
 958                 "Doppelte Page-Ids in der Tabpage" );
 959     aTabCtrl.InsertPage( nId, rRiderBitmap, nPos );
 960     pImpl->pData->Append(
 961         new Data_Impl( nId, pCreateFunc, pRangesFunc, bItemsOnDemand ) );
 962 }
 963 #endif
 964
 965 // -----------------------------------------------------------------------
 966
 967 void SfxTabDialog::RemoveTabPage( USHORT nId )
 968
 969 /*  [Beschreibung]
 970
 971     L"oschen der TabPage mit der ID nId
 972 */
 973
 974 {
 975     USHORT nPos = 0;
 976     aTabCtrl.RemovePage( nId );
 977     Data_Impl* pDataObject = Find( *pImpl->pData, nId, &nPos );
 978
 979     if ( pDataObject )
 980     {
 981         if ( pDataObject->pTabPage )
 982         {
 983             pDataObject->pTabPage->FillUserData();
 984             String aPageData( pDataObject->pTabPage->GetUserData() );
 985             if ( aPageData.Len() )
 986             {
 987                 // save settings of this page (user data)
 988                 SvtViewOptions aPageOpt( E_TABPAGE, String::CreateFromInt32( pDataObject->nId ) );
 989                 aPageOpt.SetUserItem( USERITEM_NAME, makeAny( OUString( aPageData ) ) );
 990             }
 991
 992             if ( pDataObject->bOnDemand )
 993                 delete (SfxItemSet*)&pDataObject->pTabPage->GetItemSet();
 994             delete pDataObject->pTabPage;
 995         }
 996
 997         delete pDataObject;
 998         pImpl->pData->Remove( nPos );
 999     }
1000     else
1001     {
1002         DBG_WARNINGFILE( "TabPage-Id nicht bekannt" );
1003     }
1004 }
1005
1006 // -----------------------------------------------------------------------
1007
1008 void SfxTabDialog::PageCreated
1009
1010 /*  [Beschreibung]
1011
1012     Defaultimplemetierung der virtuellen Methode.
1013     Diese wird unmittelbar nach dem Erzeugen einer Seite gerufen.
1014     Hier kann der Dialog direkt an der TabPage Methoden rufen.
1015 */
1016
1017 (
1018     USHORT,                     // Id der erzeugten Seite
1019     SfxTabPage&         // Referenz auf die erzeugte Seite
1020 )
1021 {
1022 }
1023
1024 // -----------------------------------------------------------------------
1025
1026 SfxItemSet* SfxTabDialog::GetInputSetImpl()
1027
1028 /*  [Beschreibung]
1029
1030     Abgeleitete Klassen legen ggf. fuer den InputSet neuen Speicher an.
1031     Dieser mu\s im Destruktor auch wieder freigegeben werden. Dazu mu\s
1032     diese Methode gerufen werden.
1033 */
1034
1035 {
1036     return (SfxItemSet*)pSet;
1037 }
1038
1039 // -----------------------------------------------------------------------
1040
1041 SfxTabPage* SfxTabDialog::GetTabPage( USHORT nPageId ) const
1042
1043 /*  [Beschreibung]
1044
1045     TabPage mit der "Ubergebenen Id zur"uckgeben.
1046 */
1047
1048 {
1049     USHORT nPos = 0;
1050     Data_Impl* pDataObject = Find( *pImpl->pData, nPageId, &nPos );
1051
1052     if ( pDataObject )
1053         return pDataObject->pTabPage;
1054     return NULL;
1055 }
1056
1057 // -----------------------------------------------------------------------
1058
1059 BOOL SfxTabDialog::IsInOK() const
1060
1061 /*  [Beschreibung]
1062
1063 */
1064
1065 {
1066     return pImpl->bInOK;
1067 }
1068
1069 // -----------------------------------------------------------------------
1070
1071 short SfxTabDialog::Ok()
1072
1073 /*  [Beschreibung]
1074
1075     Ok-Handler des Dialogs
1076     Das OutputSet wird erstellt und jede Seite wird mit
1077     dem bzw. ihrem speziellen OutputSet durch Aufruf der Methode
1078     <SfxTabPage::FillItemSet(SfxItemSet &)> dazu aufgefordert,
1079     die vom Benuzter eingestellten Daten in das Set zu tun.
1080
1081     [R"uckgabewert]
1082
1083     RET_OK:     wenn mindestens eine Seite TRUE als Returnwert von
1084             FillItemSet geliefert hat, sonst RET_CANCEL.
1085 */
1086
1087 {
1088     pImpl->bInOK = TRUE;
1089
1090     if ( !pOutSet )
1091     {
1092         if ( !pExampleSet && pSet )
1093             pOutSet = pSet->Clone( FALSE );     // ohne Items
1094         else if ( pExampleSet )
1095             pOutSet = new SfxItemSet( *pExampleSet );
1096     }
1097     BOOL bModified = FALSE;
1098
1099     const USHORT nCount = pImpl->pData->Count();
1100
1101     for ( USHORT i = 0; i < nCount; ++i )
1102     {
1103         Data_Impl* pDataObject = pImpl->pData->GetObject(i);
1104         SfxTabPage* pTabPage = pDataObject->pTabPage;
1105
1106         if ( pTabPage )
1107         {
1108             if ( pDataObject->bOnDemand )
1109             {
1110                 SfxItemSet& rSet = (SfxItemSet&)pTabPage->GetItemSet();
1111                 rSet.ClearItem();
1112                 bModified |= pTabPage->FillItemSet( rSet );
1113             }
1114             else if ( pSet && !pTabPage->HasExchangeSupport() )
1115             {
1116                 SfxItemSet aTmp( *pSet->GetPool(), pSet->GetRanges() );
1117
1118                 if ( pTabPage->FillItemSet( aTmp ) )
1119                 {
1120                     bModified |= TRUE;
1121                     pExampleSet->Put( aTmp );
1122                     pOutSet->Put( aTmp );
1123                 }
1124             }
1125         }
1126     }
1127
1128     if ( pImpl->bModified || ( pOutSet && pOutSet->Count() > 0 ) )
1129         bModified |= TRUE;
1130
1131     if ( bFmt == 2 )
1132         bModified |= TRUE;
1133     return bModified ? RET_OK : RET_CANCEL;
1134 }
1135
1136 // -----------------------------------------------------------------------
1137
1138 IMPL_LINK( SfxTabDialog, CancelHdl, Button*, pButton )
1139 {
1140     (void)pButton; //unused
1141     Close();
1142     return 0;
1143 }
1144
1145 // -----------------------------------------------------------------------
1146
1147 SfxItemSet* SfxTabDialog::CreateInputItemSet( USHORT )
1148
1149 /*  [Beschreibung]
1150
1151     Defaultimplemetierung der virtuellen Methode.
1152     Diese wird gerufen, wenn Pages ihre Sets onDenamd anlegen
1153 */
1154
1155 {
1156     DBG_WARNINGFILE( "CreateInputItemSet nicht implementiert" );
1157     return new SfxAllItemSet( SFX_APP()->GetPool() );
1158 }
1159
1160 // -----------------------------------------------------------------------
1161
1162 const SfxItemSet* SfxTabDialog::GetRefreshedSet()
1163
1164 /*  [Beschreibung]
1165
1166     Defaultimplemetierung der virtuellen Methode.
1167     Diese wird gerufen, wenn <SfxTabPage::DeactivatePage(SfxItemSet *)>
1168     <SfxTabPage::REFRESH_SET> liefert.
1169 */
1170
1171 {
1172     DBG_ERRORFILE( "GetRefreshedSet nicht implementiert" );
1173     return 0;
1174 }
1175
1176 // -----------------------------------------------------------------------
1177
1178 IMPL_LINK( SfxTabDialog, OkHdl, Button *, EMPTYARG )
1179
1180 /*  [Beschreibung]
1181
1182     Handler des Ok-Buttons
1183     Dieser ruft f"ur die aktuelle Seite
1184     <SfxTabPage::DeactivatePage(SfxItemSet *)>.
1185     Liefert diese <SfxTabPage::LEAVE_PAGE>, wird <SfxTabDialog::Ok()> gerufen
1186     und so der Dialog beendet.
1187 */
1188
1189 {
1190     pImpl->bInOK = TRUE;
1191
1192     if ( OK_Impl() )
1193     {
1194         if ( pImpl->bModal )
1195             EndDialog( Ok() );
1196         else
1197         {
1198             Ok();
1199             Close();
1200         }
1201     }
1202     return 0;
1203 }
1204
1205 // -----------------------------------------------------------------------
1206
1207 bool SfxTabDialog::PrepareLeaveCurrentPage()
1208 {
1209     USHORT const nId = aTabCtrl.GetCurPageId();
1210     SfxTabPage* pPage = dynamic_cast<SfxTabPage*> (aTabCtrl.GetTabPage( nId ));
1211     bool bEnd = !pPage;
1212
1213     if ( pPage )
1214     {
1215         int nRet = SfxTabPage::LEAVE_PAGE;
1216         if ( pSet )
1217         {
1218             SfxItemSet aTmp( *pSet->GetPool(), pSet->GetRanges() );
1219
1220             if ( pPage->HasExchangeSupport() )
1221                 nRet = pPage->DeactivatePage( &aTmp );
1222             else
1223                 nRet = pPage->DeactivatePage( NULL );
1224
1225             if ( ( SfxTabPage::LEAVE_PAGE & nRet ) == SfxTabPage::LEAVE_PAGE
1226                  && aTmp.Count() )
1227             {
1228                 pExampleSet->Put( aTmp );
1229                 pOutSet->Put( aTmp );
1230             }
1231         }
1232         else
1233             nRet = pPage->DeactivatePage( NULL );
1234         bEnd = nRet;
1235     }
1236
1237     return bEnd;
1238 }
1239
1240
1241 // -----------------------------------------------------------------------
1242
1243 IMPL_LINK( SfxTabDialog, UserHdl, Button *, EMPTYARG )
1244
1245 /*  [Beschreibung]
1246
1247     Handler des User-Buttons
1248     Dieser ruft f"ur die aktuelle Seite
1249     <SfxTabPage::DeactivatePage(SfxItemSet *)>.
1250     Liefert diese <SfxTabPage::LEAVE_PAGE>, wird <SfxTabDialog::Ok()> gerufen.
1251     Mit dem Return-Wert von <SfxTabDialog::Ok()> wird dann der Dialog beendet.
1252 */
1253
1254 {
1255     if ( PrepareLeaveCurrentPage () )
1256     {
1257         short nRet = Ok();
1258
1259         if ( RET_OK == nRet )
1260             nRet = RET_USER;
1261         else
1262             nRet = RET_USER_CANCEL;
1263         EndDialog( nRet );
1264     }
1265     return 0;
1266 }
1267
1268 // -----------------------------------------------------------------------
1269
1270 IMPL_LINK( SfxTabDialog, ResetHdl, Button *, EMPTYARG )
1271
1272 /*  [Beschreibung]
1273
1274     Handler hinter dem Zur"ucksetzen-Button.
1275     Die aktuelle Page wird mit ihren initialen Daten
1276     neu initialisiert; alle Einstellungen, die der Benutzer
1277     auf dieser Seite get"atigt hat, werden aufgehoben.
1278 */
1279
1280 {
1281     const USHORT nId = aTabCtrl.GetCurPageId();
1282     Data_Impl* pDataObject = Find( *pImpl->pData, nId );
1283     DBG_ASSERT( pDataObject, "Id nicht bekannt" );
1284
1285     if ( pDataObject->bOnDemand )
1286     {
1287         // CSet auf AIS hat hier Probleme, daher getrennt
1288         const SfxItemSet* pItemSet = &pDataObject->pTabPage->GetItemSet();
1289         pDataObject->pTabPage->Reset( *(SfxItemSet*)pItemSet );
1290     }
1291     else
1292         pDataObject->pTabPage->Reset( *pSet );
1293     return 0;
1294 }
1295
1296 // -----------------------------------------------------------------------
1297
1298 IMPL_LINK( SfxTabDialog, BaseFmtHdl, Button *, EMPTYARG )
1299
1300 /*  [Beschreibung]
1301
1302     Handler hinter dem Standard-Button.
1303     Dieser Button steht beim Bearbeiten von StyleSheets zur Verf"ugung.
1304     Alle in dem bearbeiteten StyleSheet eingestellten Attribute
1305     werden gel"oscht.
1306 */
1307
1308 {
1309     const USHORT nId = aTabCtrl.GetCurPageId();
1310     Data_Impl* pDataObject = Find( *pImpl->pData, nId );
1311     DBG_ASSERT( pDataObject, "Id nicht bekannt" );
1312     bFmt = 2;
1313
1314     if ( pDataObject->fnGetRanges )
1315     {
1316         if ( !pExampleSet )
1317             pExampleSet = new SfxItemSet( *pSet );
1318
1319         const SfxItemPool* pPool = pSet->GetPool();
1320         const USHORT* pTmpRanges = (pDataObject->fnGetRanges)();
1321         SfxItemSet aTmpSet( *pExampleSet );
1322
1323         while ( *pTmpRanges )
1324         {
1325             const USHORT* pU = pTmpRanges + 1;
1326
1327             if ( *pTmpRanges == *pU )
1328             {
1329                 // Range mit zwei gleichen Werten -> nur ein Item setzen
1330                 USHORT nWh = pPool->GetWhich( *pTmpRanges );
1331                 pExampleSet->ClearItem( nWh );
1332                 aTmpSet.ClearItem( nWh );
1333                 // am OutSet mit InvalidateItem,
1334                 // damit die "Anderung wirksam wird
1335                 pOutSet->InvalidateItem( nWh );
1336             }
1337             else
1338             {
1339                 // richtiger Range mit mehreren Werten
1340                 USHORT nTmp = *pTmpRanges, nTmpEnd = *pU;
1341                 DBG_ASSERT( nTmp <= nTmpEnd, "Range ist falsch sortiert" );
1342
1343                 if ( nTmp > nTmpEnd )
1344                 {
1345                     // wenn wirklich falsch sortiert, dann neu setzen
1346                     USHORT nTmp1 = nTmp;
1347                     nTmp = nTmpEnd;
1348                     nTmpEnd = nTmp1;
1349                 }
1350
1351                 while ( nTmp <= nTmpEnd )
1352                 {
1353                     // "uber den Range iterieren, und die Items setzen
1354                     USHORT nWh = pPool->GetWhich( nTmp );
1355                     pExampleSet->ClearItem( nWh );
1356                     aTmpSet.ClearItem( nWh );
1357                     // am OutSet mit InvalidateItem,
1358                     // damit die "Anderung wirksam wird
1359                     pOutSet->InvalidateItem( nWh );
1360                     nTmp++;
1361                 }
1362             }
1363             // zum n"achsten Paar gehen
1364             pTmpRanges += 2;
1365         }
1366         // alle Items neu gesetzt -> dann an der aktuellen Page Reset() rufen
1367         DBG_ASSERT( pDataObject->pTabPage, "die Page ist weg" );
1368         pDataObject->pTabPage->Reset( aTmpSet );
1369         pDataObject->pTabPage->pImpl->mbStandard = TRUE;
1370     }
1371     return 1;
1372 }
1373
1374 // -----------------------------------------------------------------------
1375
1376 #if ENABLE_LAYOUT_SFX_TABDIALOG
1377 #define tabControlWindow pTabCtrl->GetWindow ()
1378 #else /* !ENABLE_LAYOUT_SFX_TABDIALOG */
1379 #define tabControlWindow pTabCtrl
1380 #endif /* !ENABLE_LAYOUT_SFX_TABDIALOG */
1381
1382 IMPL_LINK( SfxTabDialog, ActivatePageHdl, TabControl *, pTabCtrl )
1383
1384 /*  [Beschreibung]
1385
1386     Handler, der vor dem Umschalten auf eine andere Seite
1387     durch Starview gerufen wird.
1388     Existiert die Seite noch nicht, so wird sie erzeugt und
1389     die virtuelle Methode <SfxTabDialog::PageCreated( USHORT, SfxTabPage &)>
1390     gerufen. Existiert die Seite bereits, so wird ggf.
1391     <SfxTabPage::Reset(const SfxItemSet &)> oder
1392     <SfxTabPage::ActivatePage(const SfxItemSet &)> gerufen.
1393 */
1394
1395 {
1396     USHORT const nId = pTabCtrl->GetCurPageId();
1397
1398     DBG_ASSERT( pImpl->pData->Count(), "keine Pages angemeldet" );
1399     SFX_APP();
1400
1401     // Tab Page schon da?
1402     SfxTabPage* pTabPage = dynamic_cast<SfxTabPage*> (pTabCtrl->GetTabPage( nId ));
1403     Data_Impl* pDataObject = Find( *pImpl->pData, nId );
1404     DBG_ASSERT( pDataObject, "Id nicht bekannt" );
1405
1406     // ggf. TabPage erzeugen:
1407     if ( !pTabPage )
1408     {
1409 #if ENABLE_LAYOUT_SFX_TABDIALOG
1410         if (dynamic_cast<layout SfxTabPage*> (pTabPage))
1411             layout::TabPage::global_parent = pTabCtrl->GetWindow ();
1412 #endif
1413         const SfxItemSet* pTmpSet = 0;
1414
1415         if ( pSet )
1416         {
1417             if ( bItemsReset && pSet->GetParent() )
1418                 pTmpSet = pSet->GetParent();
1419             else
1420                 pTmpSet = pSet;
1421         }
1422
1423         if ( pTmpSet && !pDataObject->bOnDemand )
1424             pTabPage = (pDataObject->fnCreatePage)( tabControlWindow, *pTmpSet );
1425         else
1426             pTabPage = (pDataObject->fnCreatePage)
1427                             ( tabControlWindow, *CreateInputItemSet( nId ) );
1428         DBG_ASSERT( NULL == pDataObject->pTabPage, "create TabPage more than once" );
1429         pDataObject->pTabPage = pTabPage;
1430
1431 #if !ENABLE_LAYOUT_SFX_TABDIALOG
1432         pDataObject->pTabPage->SetTabDialog( this );
1433 #endif /* ENABLE_LAYOUT_SFX_TABDIALOG */
1434         SvtViewOptions aPageOpt( E_TABPAGE, String::CreateFromInt32( pDataObject->nId ) );
1435         String sUserData;
1436         Any aUserItem = aPageOpt.GetUserItem( USERITEM_NAME );
1437         OUString aTemp;
1438         if ( aUserItem >>= aTemp )
1439             sUserData = String( aTemp );
1440         pTabPage->SetUserData( sUserData );
1441         Size aSiz = pTabPage->GetSizePixel();
1442
1443 #if ENABLE_LAYOUT
1444         Size optimalSize = pTabPage->GetOptimalSize (WINDOWSIZE_MINIMUM);
1445 #if ENABLE_LAYOUT_SFX_TABDIALOG
1446         if (dynamic_cast<layout SfxTabPage*> (pTabPage))
1447         {
1448             if (optimalSize.Height () && optimalSize.Width ())
1449             {
1450                 optimalSize.Width () = optimalSize.Width ();
1451                 optimalSize.Height () = optimalSize.Height () + 40;
1452             }
1453         }
1454 #endif /* ENABLE_LAYOUT_SFX_TABDIALOG */
1455         if (optimalSize.Height () > 0 && optimalSize.Width () > 0 )
1456             aSiz = optimalSize;
1457 #endif /* ENABLE_LAYOUT */
1458
1459         Size aCtrlSiz = pTabCtrl->GetTabPageSizePixel();
1460         // Gr"o/se am TabControl nur dann setzen, wenn < als TabPage
1461         if ( aCtrlSiz.Width() < aSiz.Width() ||
1462              aCtrlSiz.Height() < aSiz.Height() )
1463         {
1464             pTabCtrl->SetTabPageSizePixel( aSiz );
1465         }
1466
1467         PageCreated( nId, *pTabPage );
1468
1469         if ( pDataObject->bOnDemand )
1470             pTabPage->Reset( (SfxItemSet &)pTabPage->GetItemSet() );
1471         else
1472             pTabPage->Reset( *pSet );
1473
1474         pTabCtrl->SetTabPage( nId, pTabPage );
1475     }
1476     else if ( pDataObject->bRefresh )
1477         pTabPage->Reset( *pSet );
1478     pDataObject->bRefresh = FALSE;
1479
1480 #if ENABLE_LAYOUT_SFX_TABDIALOG
1481     pTabCtrl->GetPagePos (nId);
1482 #endif /* ENABLE_LAYOUT_SFX_TABDIALOG */
1483
1484     if ( pExampleSet )
1485         pTabPage->ActivatePage( *pExampleSet );
1486     BOOL bReadOnly = pTabPage->IsReadOnly();
1487     ( bReadOnly || pImpl->bHideResetBtn ) ? aResetBtn.Hide() : aResetBtn.Show();
1488     return 0;
1489 }
1490
1491 // -----------------------------------------------------------------------
1492
1493 IMPL_LINK( SfxTabDialog, DeactivatePageHdl, TabControl *, pTabCtrl )
1494
1495 /*  [Beschreibung]
1496
1497     Handler, der vor dem Verlassen einer Seite durch Starview gerufen wird.
1498
1499     [Querverweise]
1500
1501     <SfxTabPage::DeactivatePage(SfxItemSet *)>
1502 */
1503
1504 {
1505     USHORT nId = pTabCtrl->GetCurPageId();
1506     SFX_APP();
1507     SfxTabPage *pPage = dynamic_cast<SfxTabPage*> (pTabCtrl->GetTabPage( nId ));
1508     DBG_ASSERT( pPage, "keine aktive Page" );
1509 #ifdef DBG_UTIL
1510     Data_Impl* pDataObject = Find( *pImpl->pData, pTabCtrl->GetCurPageId() );
1511     DBG_ASSERT( pDataObject, "keine Datenstruktur zur aktuellen Seite" );
1512     if ( pPage->HasExchangeSupport() && pDataObject->bOnDemand )
1513     {
1514         DBG_WARNING( "Datenaustausch bei ItemsOnDemand ist nicht gewuenscht!" );
1515     }
1516 #endif
1517
1518     int nRet = SfxTabPage::LEAVE_PAGE;
1519
1520     if ( !pExampleSet && pPage->HasExchangeSupport() && pSet )
1521         pExampleSet = new SfxItemSet( *pSet->GetPool(), pSet->GetRanges() );
1522
1523     if ( pSet )
1524     {
1525         SfxItemSet aTmp( *pSet->GetPool(), pSet->GetRanges() );
1526
1527         if ( pPage->HasExchangeSupport() )
1528             nRet = pPage->DeactivatePage( &aTmp );
1529         else
1530             nRet = pPage->DeactivatePage( NULL );
1531 //!             else
1532 //!                     pPage->FillItemSet( aTmp );
1533
1534         if ( ( SfxTabPage::LEAVE_PAGE & nRet ) == SfxTabPage::LEAVE_PAGE &&
1535              aTmp.Count() )
1536         {
1537             pExampleSet->Put( aTmp );
1538             pOutSet->Put( aTmp );
1539         }
1540     }
1541     else
1542     {
1543         if ( pPage->HasExchangeSupport() ) //!!!
1544         {
1545             if ( !pExampleSet )
1546             {
1547                 SfxItemPool* pPool = pPage->GetItemSet().GetPool();
1548                 pExampleSet =
1549                     new SfxItemSet( *pPool, GetInputRanges( *pPool ) );
1550             }
1551             nRet = pPage->DeactivatePage( pExampleSet );
1552         }
1553         else
1554             nRet = pPage->DeactivatePage( NULL );
1555     }
1556
1557     if ( nRet & SfxTabPage::REFRESH_SET )
1558     {
1559         pSet = GetRefreshedSet();
1560         DBG_ASSERT( pSet, "GetRefreshedSet() liefert NULL" );
1561         // alle Pages als neu zu initialsieren flaggen
1562         const USHORT nCount = pImpl->pData->Count();
1563
1564         for ( USHORT i = 0; i < nCount; ++i )
1565         {
1566             Data_Impl* pObj = (*pImpl->pData)[i];
1567
1568             if ( pObj->pTabPage != pPage ) // eigene Page nicht mehr refreshen
1569                 pObj->bRefresh = TRUE;
1570             else
1571                 pObj->bRefresh = FALSE;
1572         }
1573     }
1574     if ( nRet & SfxTabPage::LEAVE_PAGE )
1575         return TRUE;
1576     else
1577         return FALSE;
1578 }
1579
1580 // -----------------------------------------------------------------------
1581
1582 const SfxItemSet* SfxTabDialog::GetOutputItemSet
1583
1584 /*  [Beschreibung]
1585
1586     Liefert die Pages, die ihre Sets onDemand liefern, das OutputItemSet.
1587
1588     [Querverweise]
1589
1590     <SfxTabDialog::AddTabPage(USHORT, CreateTabPage, GetTabPageRanges, BOOL)>
1591     <SfxTabDialog::AddTabPage(USHORT, const String &, CreateTabPage, GetTabPageRanges, BOOL, USHORT)>
1592     <SfxTabDialog::AddTabPage(USHORT, const Bitmap &, CreateTabPage, GetTabPageRanges, BOOL, USHORT)>
1593 */
1594
1595 (
1596     USHORT nId  // die Id, unter der die Seite bei AddTabPage()
1597                 // hinzugef"ugt wurde.
1598 ) const
1599 {
1600     Data_Impl* pDataObject = Find( *pImpl->pData, nId );
1601     DBG_ASSERT( pDataObject, "TabPage nicht gefunden" );
1602
1603     if ( pDataObject )
1604     {
1605         if ( !pDataObject->pTabPage )
1606             return NULL;
1607
1608         if ( pDataObject->bOnDemand )
1609             return &pDataObject->pTabPage->GetItemSet();
1610         // else
1611         return pOutSet;
1612     }
1613     return NULL;
1614 }
1615
1616 // -----------------------------------------------------------------------
1617
1618 int SfxTabDialog::FillOutputItemSet()
1619 {
1620     int nRet = SfxTabPage::LEAVE_PAGE;
1621     if ( OK_Impl() )
1622         Ok();
1623     else
1624         nRet = SfxTabPage::KEEP_PAGE;
1625     return nRet;
1626 }
1627
1628 // -----------------------------------------------------------------------
1629
1630 #ifdef WNT
1631 int __cdecl TabDlgCmpUS_Impl( const void* p1, const void* p2 )
1632 #else
1633 #if defined(OS2) && defined(ICC)
1634 int _Optlink TabDlgCmpUS_Impl( const void* p1, const void* p2 )
1635 #else
1636 extern "C" int TabDlgCmpUS_Impl( const void* p1, const void* p2 )
1637 #endif
1638 #endif
1639
1640 /*  [Beschreibung]
1641
1642     Vergleichsfunktion f"ur qsort
1643 */
1644
1645 {
1646     return *(USHORT*)p1 - *(USHORT*)p2;
1647 }
1648
1649 // -----------------------------------------------------------------------
1650
1651 void SfxTabDialog::ShowPage( USHORT nId )
1652
1653 /*  [Beschreibung]
1654
1655     Es wird die TabPage mit der "ubergebenen Id aktiviert.
1656 */
1657
1658 {
1659     aTabCtrl.SetCurPageId( nId );
1660     ActivatePageHdl( &aTabCtrl );
1661 }
1662
1663 // -----------------------------------------------------------------------
1664
1665 const USHORT* SfxTabDialog::GetInputRanges( const SfxItemPool& rPool )
1666
1667 /*  [Beschreibung]
1668
1669     Bildet das Set "uber die Ranges aller Seiten des Dialogs.
1670     Die Pages m"ussen die statische Methode f"ur das Erfragen ihrer
1671     Ranges bei AddTabPage angegeben haben, liefern also ihre Sets onDemand.
1672
1673     [Querverweise]
1674
1675     <SfxTabDialog::AddTabPage(USHORT, CreateTabPage, GetTabPageRanges, BOOL)>
1676     <SfxTabDialog::AddTabPage(USHORT, const String &, CreateTabPage, GetTabPageRanges, BOOL, USHORT)>
1677     <SfxTabDialog::AddTabPage(USHORT, const Bitmap &, CreateTabPage, GetTabPageRanges, BOOL, USHORT)>
1678
1679     [R"uckgabewert]
1680
1681     Pointer auf nullterminiertes Array von USHORTs
1682     Dieses Array geh"ort dem Dialog und wird beim
1683     Zerst"oren des Dialogs gel"oscht.
1684 */
1685
1686 {
1687     if ( pSet )
1688     {
1689         DBG_ERRORFILE( "Set bereits vorhanden!" );
1690         return pSet->GetRanges();
1691     }
1692
1693     if ( pRanges )
1694         return pRanges;
1695     SvUShorts aUS( 16, 16 );
1696     USHORT nCount = pImpl->pData->Count();
1697
1698     USHORT i;
1699     for ( i = 0; i < nCount; ++i )
1700     {
1701         Data_Impl* pDataObject = pImpl->pData->GetObject(i);
1702
1703         if ( pDataObject->fnGetRanges )
1704         {
1705             const USHORT* pTmpRanges = (pDataObject->fnGetRanges)();
1706             const USHORT* pIter = pTmpRanges;
1707
1708             USHORT nLen;
1709             for( nLen = 0; *pIter; ++nLen, ++pIter )
1710                 ;
1711             aUS.Insert( pTmpRanges, nLen, aUS.Count() );
1712         }
1713     }
1714
1715     //! Doppelte Ids entfernen?
1716 #ifndef TF_POOLABLE
1717     if ( rPool.HasMap() )
1718 #endif
1719     {
1720         nCount = aUS.Count();
1721
1722         for ( i = 0; i < nCount; ++i )
1723             aUS[i] = rPool.GetWhich( aUS[i] );
1724     }
1725
1726     // sortieren
1727     if ( aUS.Count() > 1 )
1728         qsort( (void*)aUS.GetData(),
1729                aUS.Count(), sizeof(USHORT), TabDlgCmpUS_Impl );
1730
1731     // Ranges erzeugen
1732     //!! Auskommentiert, da fehlerhaft
1733     /*
1734     pRanges = new USHORT[aUS.Count() * 2 + 1];
1735     int j = 0;
1736     i = 0;
1737
1738     while ( i < aUS.Count() )
1739     {
1740         pRanges[j++] = aUS[i];
1741         // aufeinanderfolgende Zahlen
1742         for( ; i < aUS.Count()-1; ++i )
1743             if ( aUS[i] + 1 != aUS[i+1] )
1744                 break;
1745         pRanges[j++] = aUS[i++];
1746     }
1747     pRanges[j] = 0;             // terminierende NULL
1748     */
1749
1750     pRanges = new USHORT[aUS.Count() + 1];
1751     memcpy(pRanges, aUS.GetData(), sizeof(USHORT) * aUS.Count());
1752     pRanges[aUS.Count()] = 0;
1753     return pRanges;
1754 }
1755
1756 // -----------------------------------------------------------------------
1757
1758 void SfxTabDialog::SetInputSet( const SfxItemSet* pInSet )
1759
1760 /*  [Beschreibung]
1761
1762     Mit dieser Methode kann nachtr"aglich der Input-Set initial oder
1763     neu gesetzt werden.
1764 */
1765
1766 {
1767     FASTBOOL bSet = ( pSet != NULL );
1768
1769     pSet = pInSet;
1770
1771     if ( !bSet && !pExampleSet && !pOutSet )
1772     {
1773         pExampleSet = new SfxItemSet( *pSet );
1774         pOutSet = new SfxItemSet( *pSet->GetPool(), pSet->GetRanges() );
1775     }
1776 }
1777
1778 long SfxTabDialog::Notify( NotifyEvent& rNEvt )
1779 {
1780     if ( rNEvt.GetType() == EVENT_GETFOCUS )
1781     {
1782         SfxViewFrame* pViewFrame = GetViewFrame() ? GetViewFrame() : SfxViewFrame::Current();
1783         if ( pViewFrame )
1784         {
1785             Window* pWindow = rNEvt.GetWindow();
1786             ULONG nHelpId  = 0;
1787             while ( !nHelpId && pWindow )
1788             {
1789                 nHelpId = pWindow->GetHelpId();
1790                 pWindow = pWindow->GetParent();
1791             }
1792
1793             if ( nHelpId )
1794                 SfxHelp::OpenHelpAgent( pViewFrame->GetFrame(), nHelpId );
1795         }
1796     }
1797
1798     return TabDialog::Notify( rNEvt );
1799 }
1800
1801 END_NAMESPACE_LAYOUT_SFX_TABDIALOG