Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include <limits.h>
22 : #include <stdlib.h>
23 : #include <algorithm>
24 : #include <vcl/builder.hxx>
25 : #include <vcl/msgbox.hxx>
26 : #include <unotools/viewoptions.hxx>
27 :
28 : #include "appdata.hxx"
29 : #include "sfxtypes.hxx"
30 : #include <sfx2/tabdlg.hxx>
31 : #include <sfx2/viewfrm.hxx>
32 : #include <sfx2/app.hxx>
33 : #include <sfx2/sfxresid.hxx>
34 : #include <sfx2/sfxhelp.hxx>
35 : #include <sfx2/ctrlitem.hxx>
36 : #include <sfx2/bindings.hxx>
37 : #include <sfx2/sfxdlg.hxx>
38 : #include <sfx2/itemconnect.hxx>
39 :
40 : #include "dialog.hrc"
41 : #include "helpid.hrc"
42 :
43 : using namespace ::com::sun::star::uno;
44 :
45 : #define USERITEM_NAME OUString("UserItem")
46 :
47 0 : TYPEINIT1(SfxTabDialogItem,SfxSetItem);
48 :
49 0 : struct TabPageImpl
50 : {
51 : bool mbStandard;
52 : sfx::ItemConnectionArray maItemConn;
53 : ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame > mxFrame;
54 :
55 0 : TabPageImpl() : mbStandard( false ) {}
56 : };
57 :
58 : struct Data_Impl
59 : {
60 : sal_uInt16 nId; // The ID
61 : CreateTabPage fnCreatePage; // Pointer to Factory
62 : GetTabPageRanges fnGetRanges; // Pointer to Ranges-Function
63 : SfxTabPage* pTabPage; // The TabPage itself
64 : bool bOnDemand; // Flag: ItemSet onDemand
65 : bool bRefresh; // Flag: Page must be re-initialized
66 :
67 : // Constructor
68 0 : Data_Impl( sal_uInt16 Id, CreateTabPage fnPage,
69 : GetTabPageRanges fnRanges, bool bDemand ) :
70 :
71 : nId ( Id ),
72 : fnCreatePage( fnPage ),
73 : fnGetRanges ( fnRanges ),
74 : pTabPage ( 0 ),
75 : bOnDemand ( bDemand ),
76 0 : bRefresh ( false )
77 : {
78 0 : if ( !fnCreatePage )
79 : {
80 0 : SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();
81 0 : if ( pFact )
82 : {
83 0 : fnCreatePage = pFact->GetTabPageCreatorFunc( nId );
84 0 : fnGetRanges = pFact->GetTabPageRangesFunc( nId );
85 : }
86 : }
87 0 : }
88 : };
89 :
90 0 : SfxTabDialogItem::SfxTabDialogItem( const SfxTabDialogItem& rAttr, SfxItemPool* pItemPool )
91 0 : : SfxSetItem( rAttr, pItemPool )
92 : {
93 0 : }
94 :
95 0 : SfxTabDialogItem::SfxTabDialogItem( sal_uInt16 nId, const SfxItemSet& rItemSet )
96 0 : : SfxSetItem( nId, rItemSet )
97 : {
98 0 : }
99 :
100 0 : SfxPoolItem* SfxTabDialogItem::Clone(SfxItemPool* pToPool) const
101 : {
102 0 : return new SfxTabDialogItem( *this, pToPool );
103 : }
104 :
105 0 : SfxPoolItem* SfxTabDialogItem::Create(SvStream& /*rStream*/, sal_uInt16 /*nVersion*/) const
106 : {
107 : OSL_FAIL( "Use it only in UI!" );
108 0 : return NULL;
109 : }
110 :
111 : typedef std::vector<Data_Impl*> SfxTabDlgData_Impl;
112 :
113 : struct TabDlg_Impl
114 : {
115 : bool bModified : 1,
116 : bModal : 1,
117 : bHideResetBtn : 1;
118 : SfxTabDlgData_Impl aData;
119 :
120 0 : TabDlg_Impl( sal_uInt8 nCnt ) :
121 :
122 : bModified ( false ),
123 : bModal ( true ),
124 0 : bHideResetBtn ( false )
125 : {
126 0 : aData.reserve( nCnt );
127 0 : }
128 0 : ~TabDlg_Impl()
129 0 : {
130 0 : }
131 : };
132 :
133 :
134 0 : static Data_Impl* Find( const SfxTabDlgData_Impl& rArr, sal_uInt16 nId, sal_uInt16* pPos = 0)
135 : {
136 0 : const sal_uInt16 nCount = rArr.size();
137 :
138 0 : for ( sal_uInt16 i = 0; i < nCount; ++i )
139 : {
140 0 : Data_Impl* pObj = rArr[i];
141 :
142 0 : if ( pObj->nId == nId )
143 : {
144 0 : if ( pPos )
145 0 : *pPos = i;
146 0 : return pObj;
147 : }
148 : }
149 0 : return 0;
150 : }
151 :
152 0 : void SfxTabPage::SetFrame(const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& xFrame)
153 : {
154 0 : if (pImpl)
155 0 : pImpl->mxFrame = xFrame;
156 0 : }
157 :
158 0 : ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame > SfxTabPage::GetFrame()
159 : {
160 0 : if (pImpl)
161 0 : return pImpl->mxFrame;
162 0 : return ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >();
163 : }
164 :
165 0 : SfxTabPage::SfxTabPage(vcl::Window *pParent, const OString& rID, const OUString& rUIXMLDescription, const SfxItemSet *rAttrSet)
166 : : TabPage(pParent, rID, rUIXMLDescription)
167 : , pSet ( rAttrSet )
168 : , bHasExchangeSupport ( false )
169 0 : , pImpl ( new TabPageImpl )
170 : {
171 0 : }
172 :
173 0 : SfxTabPage::~SfxTabPage()
174 : /* [Description]
175 :
176 : Destructor
177 : */
178 : {
179 0 : delete pImpl;
180 0 : }
181 :
182 0 : bool SfxTabPage::FillItemSet( SfxItemSet* rSet )
183 : {
184 0 : return pImpl->maItemConn.DoFillItemSet( *rSet, GetItemSet() );
185 : }
186 :
187 0 : void SfxTabPage::Reset( const SfxItemSet* rSet )
188 : {
189 0 : pImpl->maItemConn.DoApplyFlags( *rSet );
190 0 : pImpl->maItemConn.DoReset( *rSet );
191 0 : }
192 :
193 0 : void SfxTabPage::ActivatePage( const SfxItemSet& )
194 : /* [Description]
195 :
196 : Default implementation of the virtual ActivatePage method. This method is
197 : called when a page of dialogue supports the exchange of data between pages.
198 : <SfxTabPage::DeactivatePage(SfxItemSet *)>
199 : */
200 : {
201 0 : }
202 :
203 0 : int SfxTabPage::DeactivatePage( SfxItemSet* )
204 :
205 : /* [Description]
206 :
207 : Default implementation of the virtual DeactivatePage method. This method is
208 : called by Sfx when leaving a page; the application can, through the return
209 : value, control whether to leave the page. If the page is displayed through
210 : bHasExchangeSupport which supports data exchange between pages, then a
211 : pointer to the exchange set is passed as parameter. This takes on data for
212 : the exchange, then the set is available as a parameter in
213 : <SfxTabPage::ActivatePage(const SfxItemSet &)>.
214 :
215 : [Return value]
216 :
217 : LEAVE_PAGE; Allow leaving the page
218 : */
219 :
220 : {
221 0 : return LEAVE_PAGE;
222 : }
223 :
224 :
225 :
226 0 : void SfxTabPage::FillUserData()
227 :
228 : /* [Description]
229 :
230 : Virtual method is called by the base class in the destructor to save
231 : specific information of the TabPage in the ini-file. When overloading a
232 : string must be compiled, which is then flushed with the <SetUserData()>.
233 : */
234 :
235 : {
236 0 : }
237 :
238 :
239 :
240 0 : bool SfxTabPage::IsReadOnly() const
241 : {
242 0 : return false;
243 : }
244 :
245 :
246 :
247 0 : const SfxPoolItem* SfxTabPage::GetItem( const SfxItemSet& rSet, sal_uInt16 nSlot, bool bDeep )
248 :
249 : /* [Description]
250 :
251 : static Method: hereby are the implementations of the TabPage code
252 : being simplified.
253 : */
254 :
255 : {
256 0 : const SfxItemPool* pPool = rSet.GetPool();
257 0 : sal_uInt16 nWh = pPool->GetWhich( nSlot, bDeep );
258 0 : const SfxPoolItem* pItem = 0;
259 0 : rSet.GetItemState( nWh, true, &pItem );
260 :
261 0 : if ( !pItem && nWh != nSlot )
262 0 : pItem = &pPool->GetDefaultItem( nWh );
263 0 : return pItem;
264 : }
265 :
266 :
267 :
268 0 : const SfxPoolItem* SfxTabPage::GetOldItem( const SfxItemSet& rSet,
269 : sal_uInt16 nSlot, bool bDeep )
270 :
271 : /* [Description]
272 :
273 : This method returns an attribute for comparison of the old value.
274 : */
275 :
276 : {
277 0 : const SfxItemSet& rOldSet = GetItemSet();
278 0 : sal_uInt16 nWh = GetWhich( nSlot, bDeep );
279 0 : const SfxPoolItem* pItem = 0;
280 :
281 0 : if ( pImpl->mbStandard && rOldSet.GetParent() )
282 0 : pItem = GetItem( *rOldSet.GetParent(), nSlot );
283 0 : else if ( rSet.GetParent() &&
284 0 : SfxItemState::DONTCARE == rSet.GetItemState( nWh ) )
285 0 : pItem = GetItem( *rSet.GetParent(), nSlot );
286 : else
287 0 : pItem = GetItem( rOldSet, nSlot );
288 0 : return pItem;
289 : }
290 :
291 0 : void SfxTabPage::PageCreated( const SfxAllItemSet& /*aSet*/ )
292 : {
293 : DBG_ASSERT(false, "SfxTabPage::PageCreated should not be called");
294 0 : }
295 :
296 :
297 :
298 0 : void SfxTabPage::AddItemConnection( sfx::ItemConnectionBase* pConnection )
299 : {
300 0 : pImpl->maItemConn.AddConnection( pConnection );
301 0 : }
302 :
303 0 : SfxTabDialog* SfxTabPage::GetTabDialog() const
304 : {
305 0 : return dynamic_cast<SfxTabDialog*>(GetParentDialog());
306 : }
307 :
308 :
309 :
310 0 : SfxTabDialog::SfxTabDialog
311 : (
312 : SfxViewFrame* pViewFrame, // Frame, to which the Dialog belongs
313 : vcl::Window* pParent, // Parent Window
314 : const OString& rID, const OUString& rUIXMLDescription, //Dialog Name, Dialog .ui path
315 : const SfxItemSet* pItemSet, // Itemset with the data;
316 : // can be NULL, when Pages are onDemand
317 : bool bEditFmt // when yes -> additional Button for standard
318 : )
319 : : TabDialog(pParent, rID, rUIXMLDescription)
320 : , pFrame(pViewFrame)
321 : , pSet(pItemSet)
322 : , pOutSet(0)
323 : , pRanges(0)
324 : , nAppPageId(USHRT_MAX)
325 : , bItemsReset(false)
326 : , bStandardPushed(false)
327 0 : , pExampleSet(0)
328 : {
329 0 : Init_Impl(bEditFmt);
330 0 : }
331 :
332 :
333 :
334 0 : SfxTabDialog::SfxTabDialog
335 :
336 : /* [Description]
337 :
338 : Constructor, temporary without Frame
339 : */
340 :
341 : (
342 : vcl::Window* pParent, // Parent Window
343 : const OString& rID, const OUString& rUIXMLDescription, //Dialog Name, Dialog .ui path
344 : const SfxItemSet* pItemSet, // Itemset with the data;
345 : // can be NULL, when Pages are onDemand
346 : bool bEditFmt // when yes -> additional Button for standard
347 : )
348 : : TabDialog(pParent, rID, rUIXMLDescription)
349 : , pFrame(0)
350 : , pSet(pItemSet)
351 : , pOutSet(0)
352 : , pRanges(0)
353 : , nAppPageId(USHRT_MAX)
354 : , bItemsReset(false)
355 : , bStandardPushed(false)
356 0 : , pExampleSet(0)
357 : {
358 0 : Init_Impl(bEditFmt);
359 : DBG_WARNING( "Please use the Construtor with the ViewFrame" );
360 0 : }
361 :
362 :
363 :
364 0 : SfxTabDialog::~SfxTabDialog()
365 : {
366 0 : SavePosAndId();
367 :
368 0 : for ( SfxTabDlgData_Impl::const_iterator it = pImpl->aData.begin(); it != pImpl->aData.end(); ++it )
369 : {
370 0 : Data_Impl* pDataObject = *it;
371 :
372 0 : if ( pDataObject->pTabPage )
373 : {
374 : // save settings of all pages (user data)
375 0 : pDataObject->pTabPage->FillUserData();
376 0 : OUString aPageData( pDataObject->pTabPage->GetUserData() );
377 0 : if ( !aPageData.isEmpty() )
378 : {
379 : // save settings of all pages (user data)
380 : OUString sConfigId = OStringToOUString(pDataObject->pTabPage->GetConfigId(),
381 0 : RTL_TEXTENCODING_UTF8);
382 0 : if (sConfigId.isEmpty())
383 : {
384 : SAL_WARN("sfx.config", "Tabpage needs to be converted to .ui format");
385 0 : sConfigId = OUString::number(pDataObject->nId);
386 : }
387 :
388 0 : SvtViewOptions aPageOpt(E_TABPAGE, sConfigId);
389 0 : aPageOpt.SetUserItem( USERITEM_NAME, makeAny( OUString( aPageData ) ) );
390 : }
391 :
392 0 : if ( pDataObject->bOnDemand )
393 0 : delete (SfxItemSet*)&pDataObject->pTabPage->GetItemSet();
394 0 : delete pDataObject->pTabPage;
395 : }
396 0 : delete pDataObject;
397 : }
398 :
399 0 : delete pImpl;
400 0 : delete pOutSet;
401 0 : delete pExampleSet;
402 0 : delete [] pRanges;
403 :
404 0 : if (m_bOwnsBaseFmtBtn)
405 0 : delete m_pBaseFmtBtn;
406 0 : if (m_bOwnsResetBtn)
407 0 : delete m_pResetBtn;
408 0 : if (m_bOwnsHelpBtn)
409 0 : delete m_pHelpBtn;
410 0 : if (m_bOwnsCancelBtn)
411 0 : delete m_pCancelBtn;
412 0 : if (m_bOwnsOKBtn)
413 0 : delete m_pOKBtn;
414 0 : }
415 :
416 0 : void SfxTabDialog::Init_Impl(bool bFmtFlag)
417 : /* [Description]
418 :
419 : internal initialization of the dialogue
420 : */
421 : {
422 0 : m_pBox = get_content_area();
423 : assert(m_pBox);
424 0 : m_pUIBuilder->get(m_pTabCtrl, "tabcontrol");
425 :
426 0 : pImpl = new TabDlg_Impl(m_pTabCtrl->GetPageCount());
427 :
428 0 : m_pActionArea = get_action_area();
429 : assert(m_pActionArea);
430 :
431 0 : m_pOKBtn = m_pUIBuilder->get<PushButton>("ok");
432 0 : m_bOwnsOKBtn = m_pOKBtn == NULL;
433 0 : if (m_bOwnsOKBtn)
434 0 : m_pOKBtn = new OKButton(m_pActionArea);
435 :
436 0 : m_pApplyBtn = m_pUIBuilder->get<PushButton>("apply");
437 0 : m_pUserBtn = m_pUIBuilder->get<PushButton>("user");
438 0 : m_pCancelBtn = m_pUIBuilder->get<CancelButton>("cancel");
439 0 : m_bOwnsCancelBtn = m_pCancelBtn == NULL;
440 0 : if (m_bOwnsCancelBtn)
441 0 : m_pCancelBtn = new CancelButton(m_pActionArea);
442 :
443 0 : m_pHelpBtn = m_pUIBuilder->get<HelpButton>("help");
444 0 : m_bOwnsHelpBtn = m_pHelpBtn == NULL;
445 0 : if (m_bOwnsHelpBtn)
446 0 : m_pHelpBtn = new HelpButton(m_pActionArea);
447 :
448 0 : m_pResetBtn = m_pUIBuilder->get<PushButton>("reset");
449 0 : m_bOwnsResetBtn = m_pResetBtn == NULL;
450 0 : if (m_bOwnsResetBtn)
451 0 : m_pResetBtn = new PushButton(m_pActionArea);
452 : else
453 0 : pImpl->bHideResetBtn = !m_pResetBtn->IsVisible();
454 :
455 0 : m_pBaseFmtBtn = m_pUIBuilder->get<PushButton>("standard");
456 0 : m_bOwnsBaseFmtBtn = m_pBaseFmtBtn == NULL;
457 0 : if (m_bOwnsBaseFmtBtn)
458 0 : m_pBaseFmtBtn = new PushButton(m_pActionArea);
459 :
460 0 : m_pOKBtn->SetClickHdl( LINK( this, SfxTabDialog, OkHdl ) );
461 0 : m_pCancelBtn->SetClickHdl( LINK( this, SfxTabDialog, CancelHdl ) );
462 0 : m_pResetBtn->SetClickHdl( LINK( this, SfxTabDialog, ResetHdl ) );
463 0 : m_pResetBtn->SetText( SfxResId( STR_RESET ).toString() );
464 : m_pTabCtrl->SetActivatePageHdl(
465 0 : LINK( this, SfxTabDialog, ActivatePageHdl ) );
466 : m_pTabCtrl->SetDeactivatePageHdl(
467 0 : LINK( this, SfxTabDialog, DeactivatePageHdl ) );
468 0 : m_pActionArea->Show();
469 0 : m_pBox->Show();
470 0 : m_pTabCtrl->Show();
471 0 : m_pOKBtn->Show();
472 0 : m_pCancelBtn->Show();
473 0 : m_pHelpBtn->Show();
474 0 : m_pResetBtn->Show();
475 0 : m_pResetBtn->SetHelpId( HID_TABDLG_RESET_BTN );
476 :
477 0 : if ( m_pUserBtn )
478 : {
479 0 : m_pUserBtn->SetClickHdl( LINK( this, SfxTabDialog, UserHdl ) );
480 0 : m_pUserBtn->Show();
481 : }
482 :
483 0 : if ( bFmtFlag )
484 : {
485 0 : m_pBaseFmtBtn->SetText( SfxResId( STR_STANDARD_SHORTCUT ).toString() );
486 0 : m_pBaseFmtBtn->SetClickHdl( LINK( this, SfxTabDialog, BaseFmtHdl ) );
487 0 : m_pBaseFmtBtn->SetHelpId( HID_TABDLG_STANDARD_BTN );
488 0 : m_pBaseFmtBtn->Show();
489 : }
490 :
491 0 : if ( pSet )
492 : {
493 0 : pExampleSet = new SfxItemSet( *pSet );
494 0 : pOutSet = new SfxItemSet( *pSet->GetPool(), pSet->GetRanges() );
495 : }
496 0 : }
497 :
498 0 : void SfxTabDialog::RemoveResetButton()
499 : {
500 0 : m_pResetBtn->Hide();
501 0 : pImpl->bHideResetBtn = true;
502 0 : }
503 :
504 0 : void SfxTabDialog::RemoveStandardButton()
505 : {
506 0 : m_pBaseFmtBtn->Hide();
507 0 : }
508 :
509 0 : short SfxTabDialog::Execute()
510 : {
511 0 : if ( !m_pTabCtrl->GetPageCount() )
512 0 : return RET_CANCEL;
513 0 : Start_Impl();
514 0 : return TabDialog::Execute();
515 : }
516 :
517 :
518 :
519 0 : void SfxTabDialog::StartExecuteModal( const Link& rEndDialogHdl )
520 : {
521 0 : if ( !m_pTabCtrl->GetPageCount() )
522 0 : return;
523 0 : Start_Impl();
524 0 : TabDialog::StartExecuteModal( rEndDialogHdl );
525 : }
526 :
527 :
528 :
529 0 : void SfxTabDialog::Start( bool bShow )
530 : {
531 0 : pImpl->bModal = false;
532 0 : Start_Impl();
533 :
534 0 : if ( bShow )
535 0 : Show();
536 :
537 0 : if ( IsVisible() && ( !HasChildPathFocus() || HasFocus() ) )
538 0 : GrabFocusToFirstControl();
539 0 : }
540 :
541 :
542 :
543 0 : void SfxTabDialog::SetApplyHandler(const Link& _rHdl)
544 : {
545 : DBG_ASSERT( m_pApplyBtn, "SfxTabDialog::GetApplyHandler: no apply button enabled!" );
546 0 : if ( m_pApplyBtn )
547 0 : m_pApplyBtn->SetClickHdl( _rHdl );
548 0 : }
549 :
550 :
551 :
552 0 : void SfxTabDialog::Start_Impl()
553 : {
554 : DBG_ASSERT( pImpl->aData.size() == m_pTabCtrl->GetPageCount(), "not all pages registered" );
555 0 : sal_uInt16 nActPage = m_pTabCtrl->GetPageId( 0 );
556 :
557 : // load old settings, when exists
558 0 : SvtViewOptions aDlgOpt(E_TABDIALOG, OStringToOUString(GetHelpId(),RTL_TEXTENCODING_UTF8));
559 0 : if ( aDlgOpt.Exists() )
560 : {
561 0 : SetWindowState(OUStringToOString(aDlgOpt.GetWindowState().getStr(), RTL_TEXTENCODING_ASCII_US));
562 :
563 : // initial TabPage from Program/Help/config
564 0 : nActPage = (sal_uInt16)aDlgOpt.GetPageID();
565 :
566 0 : if ( USHRT_MAX != nAppPageId )
567 0 : nActPage = nAppPageId;
568 : else
569 : {
570 0 : sal_uInt16 nAutoTabPageId = SfxGetpApp()->Get_Impl()->nAutoTabPageId;
571 0 : if ( nAutoTabPageId )
572 0 : nActPage = nAutoTabPageId;
573 : }
574 :
575 0 : if ( TAB_PAGE_NOTFOUND == m_pTabCtrl->GetPagePos( nActPage ) )
576 0 : nActPage = m_pTabCtrl->GetPageId( 0 );
577 : }
578 0 : else if ( USHRT_MAX != nAppPageId && TAB_PAGE_NOTFOUND != m_pTabCtrl->GetPagePos( nAppPageId ) )
579 0 : nActPage = nAppPageId;
580 :
581 0 : m_pTabCtrl->SetCurPageId( nActPage );
582 0 : ActivatePageHdl( m_pTabCtrl );
583 0 : }
584 :
585 0 : void SfxTabDialog::AddTabPage( sal_uInt16 nId, const OUString &rRiderText, bool bItemsOnDemand, sal_uInt16 nPos )
586 : {
587 0 : AddTabPage( nId, rRiderText, 0, 0, bItemsOnDemand, nPos );
588 0 : }
589 :
590 : /*
591 : Adds a page to the dialog. The Name must correspond to a entry in the
592 : TabControl in the dialog .ui
593 : */
594 0 : sal_uInt16 SfxTabDialog::AddTabPage
595 : (
596 : const OString &rName, // Page ID
597 : CreateTabPage pCreateFunc, // Pointer to the Factory Method
598 : GetTabPageRanges pRangesFunc, // Pointer to the Method for quering
599 : // Ranges onDemand
600 : bool bItemsOnDemand // indicates whether the set of this page is
601 : // requested when created
602 : )
603 : {
604 0 : sal_uInt16 nId = m_pTabCtrl->GetPageId(rName);
605 : pImpl->aData.push_back(
606 0 : new Data_Impl( nId, pCreateFunc, pRangesFunc, bItemsOnDemand ) );
607 0 : return nId;
608 : }
609 :
610 : /*
611 : Adds a page to the dialog. The Name must correspond to a entry in the
612 : TabControl in the dialog .ui
613 : */
614 0 : sal_uInt16 SfxTabDialog::AddTabPage
615 : (
616 : const OString &rName, // Page ID
617 : sal_uInt16 nPageCreateId // Identifier of the Factory Method to create the page
618 : )
619 : {
620 0 : SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();
621 : assert(pFact);
622 0 : CreateTabPage pCreateFunc = pFact->GetTabPageCreatorFunc(nPageCreateId);
623 : assert(pCreateFunc);
624 0 : GetTabPageRanges pRangesFunc = pFact->GetTabPageRangesFunc(nPageCreateId);
625 0 : sal_uInt16 nPageId = m_pTabCtrl->GetPageId(rName);
626 0 : pImpl->aData.push_back(new Data_Impl(nPageId, pCreateFunc, pRangesFunc, false));
627 0 : return nPageId;
628 : }
629 :
630 :
631 :
632 0 : void SfxTabDialog::AddTabPage
633 :
634 : /* [Description]
635 :
636 : Add a page to the dialog. The Rider text is passed on, the page has no
637 : counterpart in the TabControl in the resource of the dialogue.
638 : */
639 :
640 : (
641 : sal_uInt16 nId,
642 : const OUString& rRiderText,
643 : CreateTabPage pCreateFunc,
644 : GetTabPageRanges pRangesFunc,
645 : bool bItemsOnDemand,
646 : sal_uInt16 nPos
647 : )
648 : {
649 : DBG_ASSERT( TAB_PAGE_NOTFOUND == m_pTabCtrl->GetPagePos( nId ),
650 : "Double Page-Ids in the Tabpage" );
651 0 : m_pTabCtrl->InsertPage( nId, rRiderText, nPos );
652 : pImpl->aData.push_back(
653 0 : new Data_Impl( nId, pCreateFunc, pRangesFunc, bItemsOnDemand ) );
654 0 : }
655 :
656 0 : void SfxTabDialog::RemoveTabPage( sal_uInt16 nId )
657 :
658 : /* [Description]
659 :
660 : Delete the TabPage with ID nId
661 : */
662 :
663 : {
664 0 : sal_uInt16 nPos = 0;
665 0 : m_pTabCtrl->RemovePage( nId );
666 0 : Data_Impl* pDataObject = Find( pImpl->aData, nId, &nPos );
667 :
668 0 : if ( pDataObject )
669 : {
670 0 : if ( pDataObject->pTabPage )
671 : {
672 0 : pDataObject->pTabPage->FillUserData();
673 0 : OUString aPageData( pDataObject->pTabPage->GetUserData() );
674 0 : if ( !aPageData.isEmpty() )
675 : {
676 : // save settings of this page (user data)
677 : OUString sConfigId = OStringToOUString(pDataObject->pTabPage->GetConfigId(),
678 0 : RTL_TEXTENCODING_UTF8);
679 0 : if (sConfigId.isEmpty())
680 : {
681 : SAL_WARN("sfx.config", "Tabpage needs to be converted to .ui format");
682 0 : sConfigId = OUString::number(pDataObject->nId);
683 : }
684 :
685 0 : SvtViewOptions aPageOpt(E_TABPAGE, sConfigId);
686 0 : aPageOpt.SetUserItem( USERITEM_NAME, makeAny( OUString( aPageData ) ) );
687 : }
688 :
689 0 : if ( pDataObject->bOnDemand )
690 0 : delete (SfxItemSet*)&pDataObject->pTabPage->GetItemSet();
691 0 : delete pDataObject->pTabPage;
692 : }
693 :
694 0 : delete pDataObject;
695 0 : pImpl->aData.erase( pImpl->aData.begin() + nPos );
696 : }
697 : else
698 : {
699 : SAL_INFO( "sfx.dialog", "TabPage-Id not known" );
700 : }
701 0 : }
702 :
703 0 : void SfxTabDialog::RemoveTabPage(const OString &rName)
704 : {
705 0 : RemoveTabPage(m_pTabCtrl->GetPageId(rName));
706 0 : }
707 :
708 :
709 :
710 0 : void SfxTabDialog::PageCreated
711 :
712 : /* [Description]
713 :
714 : Default implementation of the virtual method. This is called immediately
715 : after creating a page. Here the dialogue can call the TabPage Method
716 : directly.
717 : */
718 :
719 : (
720 : sal_uInt16, // Id of the created page
721 : SfxTabPage& // Reference to the created page
722 : )
723 : {
724 0 : }
725 :
726 :
727 :
728 0 : SfxItemSet* SfxTabDialog::GetInputSetImpl()
729 :
730 : /* [Description]
731 :
732 : Derived classes may create new storage for the InputSet. This has to be
733 : released in the Destructor. To do this, this method must be called.
734 : */
735 :
736 : {
737 0 : return (SfxItemSet*)pSet;
738 : }
739 :
740 :
741 :
742 0 : SfxTabPage* SfxTabDialog::GetTabPage( sal_uInt16 nPageId ) const
743 :
744 : /* [Description]
745 :
746 : Return TabPage with the specified Id.
747 : */
748 :
749 : {
750 0 : sal_uInt16 nPos = 0;
751 0 : Data_Impl* pDataObject = Find( pImpl->aData, nPageId, &nPos );
752 :
753 0 : if ( pDataObject )
754 0 : return pDataObject->pTabPage;
755 0 : return NULL;
756 : }
757 :
758 0 : void SfxTabDialog::SavePosAndId()
759 : {
760 : // save settings (screen position and current page)
761 0 : SvtViewOptions aDlgOpt(E_TABDIALOG, OStringToOUString(GetHelpId(),RTL_TEXTENCODING_UTF8));
762 0 : aDlgOpt.SetWindowState(OStringToOUString(GetWindowState(WINDOWSTATE_MASK_POS),RTL_TEXTENCODING_ASCII_US));
763 : // to-do replace with name of page when all pages are converted to .ui
764 0 : aDlgOpt.SetPageID( m_pTabCtrl->GetCurPageId() );
765 0 : }
766 :
767 :
768 :
769 0 : short SfxTabDialog::Ok()
770 :
771 : /* [Description]
772 :
773 : Ok handler for the Dialogue.
774 :
775 : Dialog's current location and current page are saved for the next time
776 : the dialog is shown.
777 :
778 : The OutputSet is created and for each page this or the special OutputSet
779 : is set by calling the method <SfxTabPage::FillItemSet(SfxItemSet &)>, to
780 : insert the entered data by the user into the set.
781 :
782 : [Return value]
783 :
784 : RET_OK: if at least one page has returned from FillItemSet,
785 : otherwise RET_CANCEL.
786 : */
787 : {
788 0 : SavePosAndId(); //See fdo#38828 "Apply" resetting window position
789 :
790 0 : if ( !pOutSet )
791 : {
792 0 : if ( !pExampleSet && pSet )
793 0 : pOutSet = pSet->Clone( false ); // without Items
794 0 : else if ( pExampleSet )
795 0 : pOutSet = new SfxItemSet( *pExampleSet );
796 : }
797 0 : bool bModified = false;
798 :
799 0 : for ( SfxTabDlgData_Impl::const_iterator it = pImpl->aData.begin(); it != pImpl->aData.end(); ++it )
800 : {
801 0 : Data_Impl* pDataObject = *it;
802 0 : SfxTabPage* pTabPage = pDataObject->pTabPage;
803 :
804 0 : if ( pTabPage )
805 : {
806 0 : if ( pDataObject->bOnDemand )
807 : {
808 0 : SfxItemSet& rSet = (SfxItemSet&)pTabPage->GetItemSet();
809 0 : rSet.ClearItem();
810 0 : bModified |= pTabPage->FillItemSet( &rSet );
811 : }
812 0 : else if ( pSet && !pTabPage->HasExchangeSupport() )
813 : {
814 0 : SfxItemSet aTmp( *pSet->GetPool(), pSet->GetRanges() );
815 :
816 0 : if ( pTabPage->FillItemSet( &aTmp ) )
817 : {
818 0 : bModified |= true;
819 0 : if (pExampleSet)
820 0 : pExampleSet->Put( aTmp );
821 0 : pOutSet->Put( aTmp );
822 0 : }
823 : }
824 : }
825 : }
826 :
827 0 : if ( pImpl->bModified || ( pOutSet && pOutSet->Count() > 0 ) )
828 0 : bModified |= true;
829 :
830 0 : if (bStandardPushed)
831 0 : bModified |= true;
832 0 : return bModified ? RET_OK : RET_CANCEL;
833 : }
834 :
835 0 : IMPL_LINK_NOARG(SfxTabDialog, CancelHdl)
836 : {
837 0 : EndDialog( RET_USER_CANCEL );
838 0 : return 0;
839 : }
840 :
841 :
842 :
843 0 : SfxItemSet* SfxTabDialog::CreateInputItemSet( sal_uInt16 )
844 :
845 : /* [Description]
846 :
847 : Default implementation of the virtual Method.
848 : This is called when pages create their sets onDemand.
849 : */
850 :
851 : {
852 : SAL_WARN( "sfx.dialog", "CreateInputItemSet not implemented" );
853 0 : return new SfxAllItemSet( SfxGetpApp()->GetPool() );
854 : }
855 :
856 :
857 :
858 0 : const SfxItemSet* SfxTabDialog::GetRefreshedSet()
859 :
860 : /* [Description]
861 :
862 : Default implementation of the virtual Method.
863 : This is called, when <SfxTabPage::DeactivatePage(SfxItemSet *)>
864 : returns <SfxTabPage::REFRESH_SET>.
865 : */
866 :
867 : {
868 : SAL_INFO ( "sfx.dialog", "GetRefreshedSet not implemented" );
869 0 : return 0;
870 : }
871 :
872 :
873 :
874 0 : IMPL_LINK_NOARG(SfxTabDialog, OkHdl)
875 :
876 : /* [Description]
877 :
878 : Handler of the Ok-Buttons
879 : This calls the current page <SfxTabPage::DeactivatePage(SfxItemSet *)>.
880 : Returns <SfxTabPage::LEAVE_PAGE>, <SfxTabDialog::Ok()> is called
881 : and the Dialog is ended.
882 : */
883 :
884 : {
885 0 : if (PrepareLeaveCurrentPage())
886 : {
887 0 : if ( pImpl->bModal )
888 0 : EndDialog( Ok() );
889 : else
890 : {
891 0 : Ok();
892 0 : Close();
893 : }
894 : }
895 0 : return 0;
896 : }
897 :
898 0 : bool SfxTabDialog::Apply()
899 : {
900 0 : bool bApplied = false;
901 0 : if (PrepareLeaveCurrentPage())
902 0 : bApplied = (Ok() == RET_OK);
903 0 : return bApplied;
904 : }
905 :
906 :
907 :
908 0 : bool SfxTabDialog::PrepareLeaveCurrentPage()
909 : {
910 0 : sal_uInt16 const nId = m_pTabCtrl->GetCurPageId();
911 0 : SfxTabPage* pPage = dynamic_cast<SfxTabPage*> (m_pTabCtrl->GetTabPage( nId ));
912 0 : bool bEnd = !pPage;
913 :
914 0 : if ( pPage )
915 : {
916 0 : int nRet = SfxTabPage::LEAVE_PAGE;
917 0 : if ( pSet )
918 : {
919 0 : SfxItemSet aTmp( *pSet->GetPool(), pSet->GetRanges() );
920 :
921 0 : if ( pPage->HasExchangeSupport() )
922 0 : nRet = pPage->DeactivatePage( &aTmp );
923 : else
924 0 : nRet = pPage->DeactivatePage( NULL );
925 :
926 0 : if ( ( SfxTabPage::LEAVE_PAGE & nRet ) == SfxTabPage::LEAVE_PAGE
927 0 : && aTmp.Count() )
928 : {
929 0 : pExampleSet->Put( aTmp );
930 0 : pOutSet->Put( aTmp );
931 0 : }
932 : }
933 : else
934 0 : nRet = pPage->DeactivatePage( NULL );
935 0 : bEnd = nRet;
936 : }
937 :
938 0 : return bEnd;
939 : }
940 :
941 :
942 :
943 :
944 0 : IMPL_LINK_NOARG(SfxTabDialog, UserHdl)
945 :
946 : /* [Description]
947 :
948 : Handler of the User-Buttons
949 : This calls the current page <SfxTabPage::DeactivatePage(SfxItemSet *)>.
950 : returns this <SfxTabPage::LEAVE_PAGE> and <SfxTabDialog::Ok()> is called.
951 : Then the Dialog is ended with the Return value <SfxTabDialog::Ok()>
952 : */
953 :
954 : {
955 0 : if ( PrepareLeaveCurrentPage () )
956 : {
957 0 : short nRet = Ok();
958 :
959 0 : if ( RET_OK == nRet )
960 0 : nRet = RET_USER;
961 : else
962 0 : nRet = RET_USER_CANCEL;
963 0 : EndDialog( nRet );
964 : }
965 0 : return 0;
966 : }
967 :
968 :
969 :
970 0 : IMPL_LINK_NOARG(SfxTabDialog, ResetHdl)
971 :
972 : /* [Description]
973 :
974 : Handler behind the reset button.
975 : The Current Page is new initialized with their initial data, all the
976 : settings that the user has made on this page are repealed.
977 : */
978 :
979 : {
980 0 : const sal_uInt16 nId = m_pTabCtrl->GetCurPageId();
981 0 : Data_Impl* pDataObject = Find( pImpl->aData, nId );
982 : DBG_ASSERT( pDataObject, "Id not known" );
983 :
984 0 : if ( pDataObject->bOnDemand )
985 : {
986 : // CSet on AIS has problems here, thus separated
987 0 : const SfxItemSet* pItemSet = &pDataObject->pTabPage->GetItemSet();
988 0 : pDataObject->pTabPage->Reset( pItemSet );
989 : }
990 : else
991 0 : pDataObject->pTabPage->Reset( pSet );
992 0 : return 0;
993 : }
994 :
995 :
996 :
997 0 : IMPL_LINK_NOARG(SfxTabDialog, BaseFmtHdl)
998 :
999 : /* [Description]
1000 :
1001 : Handler behind the Standard-Button.
1002 : This button is available when editing style sheets. All the set attributes
1003 : in the edited stylesheet are deleted.
1004 : */
1005 :
1006 : {
1007 0 : bStandardPushed = true;
1008 :
1009 0 : const sal_uInt16 nId = m_pTabCtrl->GetCurPageId();
1010 0 : Data_Impl* pDataObject = Find( pImpl->aData, nId );
1011 : DBG_ASSERT( pDataObject, "Id not known" );
1012 :
1013 0 : if ( pDataObject->fnGetRanges )
1014 : {
1015 0 : if ( !pExampleSet )
1016 0 : pExampleSet = new SfxItemSet( *pSet );
1017 :
1018 0 : const SfxItemPool* pPool = pSet->GetPool();
1019 0 : const sal_uInt16* pTmpRanges = (pDataObject->fnGetRanges)();
1020 0 : SfxItemSet aTmpSet( *pExampleSet );
1021 :
1022 0 : while ( *pTmpRanges )
1023 : {
1024 0 : const sal_uInt16* pU = pTmpRanges + 1;
1025 :
1026 0 : if ( *pTmpRanges == *pU )
1027 : {
1028 : // Range which two identical values -> only set one Item
1029 0 : sal_uInt16 nWh = pPool->GetWhich( *pTmpRanges );
1030 0 : pExampleSet->ClearItem( nWh );
1031 0 : aTmpSet.ClearItem( nWh );
1032 : // At the Outset of InvalidateItem,
1033 : // so that the change takes effect
1034 0 : pOutSet->InvalidateItem( nWh );
1035 : }
1036 : else
1037 : {
1038 : // Correct Range with multiple values
1039 0 : sal_uInt16 nTmp = *pTmpRanges, nTmpEnd = *pU;
1040 : DBG_ASSERT( nTmp <= nTmpEnd, "Range is sorted the wrong way" );
1041 :
1042 0 : if ( nTmp > nTmpEnd )
1043 : {
1044 : // If really sorted wrongly, then set new
1045 0 : sal_uInt16 nTmp1 = nTmp;
1046 0 : nTmp = nTmpEnd;
1047 0 : nTmpEnd = nTmp1;
1048 : }
1049 :
1050 0 : while ( nTmp <= nTmpEnd )
1051 : {
1052 : // Iterate over the Range and set the Items
1053 0 : sal_uInt16 nWh = pPool->GetWhich( nTmp );
1054 0 : pExampleSet->ClearItem( nWh );
1055 0 : aTmpSet.ClearItem( nWh );
1056 : // At the Outset of InvalidateItem,
1057 : // so that the change takes effect
1058 0 : pOutSet->InvalidateItem( nWh );
1059 0 : nTmp++;
1060 : }
1061 : }
1062 : // Go to the next pair
1063 0 : pTmpRanges += 2;
1064 : }
1065 : // Set all Items as new -> the call the current Page Reset()
1066 : DBG_ASSERT( pDataObject->pTabPage, "the Page is gone" );
1067 0 : pDataObject->pTabPage->Reset( &aTmpSet );
1068 0 : pDataObject->pTabPage->pImpl->mbStandard = true;
1069 : }
1070 0 : return 1;
1071 : }
1072 :
1073 :
1074 :
1075 0 : IMPL_LINK( SfxTabDialog, ActivatePageHdl, TabControl *, pTabCtrl )
1076 :
1077 : /* [Description]
1078 :
1079 : Handler that is called by StarView for switching to a different page.
1080 : If the page not exist yet then it is created and the virtual Method
1081 : <SfxTabDialog::PageCreated( sal_uInt16, SfxTabPage &)> is called. If the page
1082 : exist, then the if possible the <SfxTabPage::Reset(const SfxItemSet &)> or
1083 : <SfxTabPage::ActivatePage(const SfxItemSet &)> is called.
1084 : */
1085 :
1086 : {
1087 0 : sal_uInt16 nId = pTabCtrl->GetCurPageId();
1088 :
1089 : DBG_ASSERT( pImpl->aData.size(), "no Pages registered" );
1090 0 : SfxGetpApp();
1091 :
1092 : // Tab Page schon da?
1093 0 : SfxTabPage* pTabPage = dynamic_cast<SfxTabPage*> (pTabCtrl->GetTabPage( nId ));
1094 0 : Data_Impl* pDataObject = Find( pImpl->aData, nId );
1095 :
1096 : //UUUU fallback to 1st page when requested one does not exist
1097 0 : if(!pDataObject && pTabCtrl->GetPageCount())
1098 : {
1099 0 : pTabCtrl->SetCurPageId(pTabCtrl->GetPageId(0));
1100 0 : nId = pTabCtrl->GetCurPageId();
1101 0 : pTabPage = dynamic_cast< SfxTabPage* >(pTabCtrl->GetTabPage(nId));
1102 0 : pDataObject = Find(pImpl->aData, nId);
1103 : }
1104 :
1105 : assert(pDataObject); //Id not known
1106 0 : if (!pDataObject)
1107 0 : return 0;
1108 :
1109 : // Create TabPage if possible:
1110 0 : if ( !pTabPage )
1111 : {
1112 0 : const SfxItemSet* pTmpSet = 0;
1113 :
1114 0 : if ( pSet )
1115 : {
1116 0 : if ( bItemsReset && pSet->GetParent() )
1117 0 : pTmpSet = pSet->GetParent();
1118 : else
1119 0 : pTmpSet = pSet;
1120 : }
1121 :
1122 0 : if ( pTmpSet && !pDataObject->bOnDemand )
1123 0 : pTabPage = (pDataObject->fnCreatePage)( pTabCtrl, pTmpSet );
1124 : else
1125 : pTabPage = (pDataObject->fnCreatePage)
1126 0 : ( pTabCtrl, CreateInputItemSet( nId ) );
1127 : DBG_ASSERT( NULL == pDataObject->pTabPage, "create TabPage more than once" );
1128 0 : pDataObject->pTabPage = pTabPage;
1129 :
1130 0 : OUString sConfigId = OStringToOUString(pTabPage->GetConfigId(), RTL_TEXTENCODING_UTF8);
1131 0 : if (sConfigId.isEmpty())
1132 : {
1133 : SAL_WARN("sfx.config", "Tabpage needs to be converted to .ui format");
1134 0 : sConfigId = OUString::number(pDataObject->nId);
1135 : }
1136 0 : SvtViewOptions aPageOpt(E_TABPAGE, sConfigId);
1137 0 : OUString sUserData;
1138 0 : Any aUserItem = aPageOpt.GetUserItem( USERITEM_NAME );
1139 0 : OUString aTemp;
1140 0 : if ( aUserItem >>= aTemp )
1141 0 : sUserData = aTemp;
1142 0 : pTabPage->SetUserData( sUserData );
1143 0 : Size aSiz = pTabPage->GetSizePixel();
1144 :
1145 0 : Size aCtrlSiz = pTabCtrl->GetTabPageSizePixel();
1146 : // Only set Size on TabControl when < as TabPage
1147 0 : if ( aCtrlSiz.Width() < aSiz.Width() ||
1148 0 : aCtrlSiz.Height() < aSiz.Height() )
1149 : {
1150 0 : pTabCtrl->SetTabPageSizePixel( aSiz );
1151 : }
1152 :
1153 0 : PageCreated( nId, *pTabPage );
1154 :
1155 0 : if ( pDataObject->bOnDemand )
1156 0 : pTabPage->Reset( &pTabPage->GetItemSet() );
1157 : else
1158 0 : pTabPage->Reset( pSet );
1159 :
1160 0 : pTabCtrl->SetTabPage( nId, pTabPage );
1161 : }
1162 0 : else if ( pDataObject->bRefresh )
1163 0 : pTabPage->Reset( pSet );
1164 0 : pDataObject->bRefresh = false;
1165 :
1166 0 : if ( pExampleSet )
1167 0 : pTabPage->ActivatePage( *pExampleSet );
1168 0 : bool bReadOnly = pTabPage->IsReadOnly();
1169 0 : ( bReadOnly || pImpl->bHideResetBtn ) ? m_pResetBtn->Hide() : m_pResetBtn->Show();
1170 0 : return 0;
1171 : }
1172 :
1173 :
1174 :
1175 0 : IMPL_LINK( SfxTabDialog, DeactivatePageHdl, TabControl *, pTabCtrl )
1176 :
1177 : /* [Description]
1178 :
1179 : Handler that is called by StarView before leaving a page.
1180 :
1181 : [Cross-reference]
1182 :
1183 : <SfxTabPage::DeactivatePage(SfxItemSet *)>
1184 : */
1185 :
1186 : {
1187 0 : sal_uInt16 nId = pTabCtrl->GetCurPageId();
1188 0 : SfxGetpApp();
1189 0 : SfxTabPage *pPage = dynamic_cast<SfxTabPage*> (pTabCtrl->GetTabPage( nId ));
1190 : DBG_ASSERT( pPage, "no active Page" );
1191 0 : if (!pPage)
1192 0 : return sal_False;
1193 : #ifdef DBG_UTIL
1194 : Data_Impl* pDataObject = Find( pImpl->aData, pTabCtrl->GetCurPageId() );
1195 : DBG_ASSERT( pDataObject, "no Data structure for current page" );
1196 : if ( pPage->HasExchangeSupport() && pDataObject->bOnDemand )
1197 : {
1198 : DBG_WARNING( "Data exchange in ItemsOnDemand is not desired!" );
1199 : }
1200 : #endif
1201 :
1202 0 : int nRet = SfxTabPage::LEAVE_PAGE;
1203 :
1204 0 : if ( !pExampleSet && pPage->HasExchangeSupport() && pSet )
1205 0 : pExampleSet = new SfxItemSet( *pSet->GetPool(), pSet->GetRanges() );
1206 :
1207 0 : if ( pSet )
1208 : {
1209 0 : SfxItemSet aTmp( *pSet->GetPool(), pSet->GetRanges() );
1210 :
1211 0 : if ( pPage->HasExchangeSupport() )
1212 0 : nRet = pPage->DeactivatePage( &aTmp );
1213 : else
1214 0 : nRet = pPage->DeactivatePage( NULL );
1215 0 : if ( ( SfxTabPage::LEAVE_PAGE & nRet ) == SfxTabPage::LEAVE_PAGE &&
1216 0 : aTmp.Count() )
1217 : {
1218 0 : pExampleSet->Put( aTmp );
1219 0 : pOutSet->Put( aTmp );
1220 0 : }
1221 : }
1222 : else
1223 : {
1224 0 : if ( pPage->HasExchangeSupport() ) //!!!
1225 : {
1226 0 : if ( !pExampleSet )
1227 : {
1228 0 : SfxItemPool* pPool = pPage->GetItemSet().GetPool();
1229 : pExampleSet =
1230 0 : new SfxItemSet( *pPool, GetInputRanges( *pPool ) );
1231 : }
1232 0 : nRet = pPage->DeactivatePage( pExampleSet );
1233 : }
1234 : else
1235 0 : nRet = pPage->DeactivatePage( NULL );
1236 : }
1237 :
1238 0 : if ( nRet & SfxTabPage::REFRESH_SET )
1239 : {
1240 0 : pSet = GetRefreshedSet();
1241 : DBG_ASSERT( pSet, "GetRefreshedSet() returns NULL" );
1242 : // Flag all Pages as to be initialized as new
1243 :
1244 0 : for ( SfxTabDlgData_Impl::const_iterator it = pImpl->aData.begin(); it != pImpl->aData.end(); ++it )
1245 : {
1246 0 : Data_Impl* pObj = *it;
1247 :
1248 0 : if ( pObj->pTabPage != pPage ) // Do not refresh own Page anymore
1249 0 : pObj->bRefresh = true;
1250 : else
1251 0 : pObj->bRefresh = false;
1252 : }
1253 : }
1254 0 : if ( nRet & SfxTabPage::LEAVE_PAGE )
1255 0 : return sal_True;
1256 : else
1257 0 : return sal_False;
1258 : }
1259 :
1260 :
1261 :
1262 0 : void SfxTabDialog::ShowPage( sal_uInt16 nId )
1263 :
1264 : /* [Description]
1265 :
1266 : The TabPage is activated with the specified Id.
1267 : */
1268 :
1269 : {
1270 0 : m_pTabCtrl->SetCurPageId( nId );
1271 0 : ActivatePageHdl( m_pTabCtrl );
1272 0 : }
1273 :
1274 :
1275 :
1276 0 : const sal_uInt16* SfxTabDialog::GetInputRanges( const SfxItemPool& rPool )
1277 :
1278 : /* [Description]
1279 :
1280 : Makes the set over the range of all pages of the dialogue. Pages have the
1281 : static method for querying their range in AddTabPage, ie deliver their
1282 : sets onDemand.
1283 :
1284 : [Return value]
1285 :
1286 : Pointer to a null-terminated array of sal_uInt16. This array belongs to the
1287 : dialog and is deleted when the dialogue is destroy.
1288 :
1289 : [Cross-reference]
1290 :
1291 : <SfxTabDialog::AddTabPage(sal_uInt16, CreateTabPage, GetTabPageRanges, bool)>
1292 : <SfxTabDialog::AddTabPage(sal_uInt16, const String &, CreateTabPage, GetTabPageRanges, bool, sal_uInt16)>
1293 : <SfxTabDialog::AddTabPage(sal_uInt16, const Bitmap &, CreateTabPage, GetTabPageRanges, bool, sal_uInt16)>
1294 : */
1295 :
1296 : {
1297 0 : if ( pSet )
1298 : {
1299 : SAL_WARN( "sfx.dialog", "Set already exists!" );
1300 0 : return pSet->GetRanges();
1301 : }
1302 :
1303 0 : if ( pRanges )
1304 0 : return pRanges;
1305 0 : std::vector<sal_uInt16> aUS;
1306 :
1307 0 : for ( SfxTabDlgData_Impl::const_iterator it = pImpl->aData.begin(); it != pImpl->aData.end(); ++it )
1308 : {
1309 0 : Data_Impl* pDataObject = *it;
1310 :
1311 0 : if ( pDataObject->fnGetRanges )
1312 : {
1313 0 : const sal_uInt16* pTmpRanges = (pDataObject->fnGetRanges)();
1314 0 : const sal_uInt16* pIter = pTmpRanges;
1315 :
1316 : sal_uInt16 nLen;
1317 0 : for( nLen = 0; *pIter; ++nLen, ++pIter )
1318 : ;
1319 0 : aUS.insert( aUS.end(), pTmpRanges, pTmpRanges + nLen );
1320 : }
1321 : }
1322 :
1323 : //! Remove duplicated Ids?
1324 : {
1325 0 : sal_uInt16 nCount = aUS.size();
1326 0 : for ( sal_uInt16 i = 0; i < nCount; ++i )
1327 0 : aUS[i] = rPool.GetWhich( aUS[i] );
1328 : }
1329 :
1330 : // sort
1331 0 : if ( aUS.size() > 1 )
1332 : {
1333 0 : std::sort( aUS.begin(), aUS.end() );
1334 : }
1335 :
1336 0 : pRanges = new sal_uInt16[aUS.size() + 1];
1337 0 : std::copy( aUS.begin(), aUS.end(), pRanges );
1338 0 : pRanges[aUS.size()] = 0;
1339 0 : return pRanges;
1340 : }
1341 :
1342 :
1343 :
1344 0 : void SfxTabDialog::SetInputSet( const SfxItemSet* pInSet )
1345 :
1346 : /* [Description]
1347 :
1348 : With this method the Input-Set can subsequently be set initally or re-set.
1349 : */
1350 :
1351 : {
1352 0 : bool bSet = ( pSet != NULL );
1353 :
1354 0 : pSet = pInSet;
1355 :
1356 0 : if ( !bSet && !pExampleSet && !pOutSet )
1357 : {
1358 0 : pExampleSet = new SfxItemSet( *pSet );
1359 0 : pOutSet = new SfxItemSet( *pSet->GetPool(), pSet->GetRanges() );
1360 : }
1361 951 : }
1362 :
1363 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
