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