LCOV - code coverage report
Current view: top level - sd/source/ui/view - ViewTabBar.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 237 0.0 %
Date: 2014-04-14 Functions: 0 33 0.0 %
Legend: Lines: hit not hit

          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 "ViewTabBar.hxx"
      22             : 
      23             : #include "ViewShell.hxx"
      24             : #include "ViewShellBase.hxx"
      25             : #include "DrawViewShell.hxx"
      26             : #include "FrameView.hxx"
      27             : #include "EventMultiplexer.hxx"
      28             : #include "framework/FrameworkHelper.hxx"
      29             : #include "framework/Pane.hxx"
      30             : #include "DrawController.hxx"
      31             : 
      32             : #include "sdresid.hxx"
      33             : #include "strings.hrc"
      34             : #include "helpids.h"
      35             : #include "Client.hxx"
      36             : #include <vcl/svapp.hxx>
      37             : #include <vcl/tabpage.hxx>
      38             : #include <vcl/settings.hxx>
      39             : 
      40             : #include <osl/mutex.hxx>
      41             : #include <sfx2/viewfrm.hxx>
      42             : #include <com/sun/star/drawing/framework/ResourceId.hpp>
      43             : #include <com/sun/star/drawing/framework/XControllerManager.hpp>
      44             : #include <com/sun/star/lang/XUnoTunnel.hpp>
      45             : #include <com/sun/star/lang/DisposedException.hpp>
      46             : #include <comphelper/processfactory.hxx>
      47             : #include <comphelper/servicehelper.hxx>
      48             : #include <tools/diagnose_ex.h>
      49             : 
      50             : using namespace ::com::sun::star;
      51             : using namespace ::com::sun::star::uno;
      52             : using namespace ::com::sun::star::drawing::framework;
      53             : using ::sd::framework::FrameworkHelper;
      54             : using ::sd::tools::EventMultiplexerEvent;
      55             : 
      56             : namespace sd {
      57             : 
      58             : namespace {
      59           0 : bool IsEqual (const TabBarButton& rButton1, const TabBarButton& rButton2)
      60             : {
      61             :     return (
      62           0 :         (rButton1.ResourceId.is()
      63           0 :             && rButton2.ResourceId.is()
      64           0 :             && rButton1.ResourceId->compareTo(rButton2.ResourceId)==0)
      65           0 :         || rButton1.ButtonLabel == rButton2.ButtonLabel);
      66             : }
      67             : 
      68           0 : class TabBarControl : public ::TabControl
      69             : {
      70             : public:
      71             :     TabBarControl (
      72             :         ::Window* pParentWindow,
      73             :         const ::rtl::Reference<ViewTabBar>& rpViewTabBar);
      74             :     virtual void Paint (const Rectangle& rRect) SAL_OVERRIDE;
      75             :     virtual void ActivatePage (void) SAL_OVERRIDE;
      76             : private:
      77             :     ::rtl::Reference<ViewTabBar> mpViewTabBar;
      78             : };
      79             : 
      80             : } // end of anonymous namespace
      81             : 
      82             : 
      83             : 
      84             : 
      85             : 
      86             : class ViewTabPage : public TabPage
      87             : {
      88             : public:
      89             :     ViewTabPage (Window* pParent) : TabPage(pParent) {}
      90             :     virtual void Resize (void) SAL_OVERRIDE
      91             :     { SetPosSizePixel(Point(0,0),GetParent()->GetOutputSizePixel()); }
      92             : };
      93             : 
      94             : 
      95             : 
      96             : 
      97             : //===== ViewTabBar ============================================================
      98             : 
      99           0 : ViewTabBar::ViewTabBar (
     100             :     const Reference<XResourceId>& rxViewTabBarId,
     101             :     const Reference<frame::XController>& rxController)
     102             :     : ViewTabBarInterfaceBase(maMutex),
     103           0 :       mpTabControl(new TabBarControl(GetAnchorWindow(rxViewTabBarId,rxController), this)),
     104             :       mxController(rxController),
     105             :       maTabBarButtons(),
     106             :       mpTabPage(NULL),
     107             :       mxViewTabBarId(rxViewTabBarId),
     108           0 :       mpViewShellBase(NULL)
     109             : {
     110             :     // Set one new tab page for all tab entries.  We need it only to
     111             :     // determine the height of the tab bar.
     112           0 :     mpTabPage.reset(new TabPage (mpTabControl.get()));
     113           0 :     mpTabPage->Hide();
     114             : 
     115             :     // add some space before the tabitems
     116           0 :     mpTabControl->SetItemsOffset(Point(5, 3));
     117             : 
     118             :     // Tunnel through the controller and use the ViewShellBase to obtain the
     119             :     // view frame.
     120             :     try
     121             :     {
     122           0 :         Reference<lang::XUnoTunnel> xTunnel (mxController, UNO_QUERY_THROW);
     123             :         DrawController* pController = reinterpret_cast<DrawController*>(
     124           0 :             xTunnel->getSomething(DrawController::getUnoTunnelId()));
     125           0 :         mpViewShellBase = pController->GetViewShellBase();
     126             :     }
     127           0 :     catch (const RuntimeException&)
     128             :     {
     129             :     }
     130             : 
     131             :     // Register as listener at XConfigurationController.
     132           0 :     Reference<XControllerManager> xControllerManager (mxController, UNO_QUERY);
     133           0 :     if (xControllerManager.is())
     134             :     {
     135           0 :         mxConfigurationController = xControllerManager->getConfigurationController();
     136           0 :         if (mxConfigurationController.is())
     137             :         {
     138           0 :             mxConfigurationController->addConfigurationChangeListener(
     139             :                 this,
     140             :                     FrameworkHelper::msResourceActivationEvent,
     141           0 :                 Any());
     142             :         }
     143             :     }
     144             : 
     145           0 :     mpTabControl->Show();
     146             : 
     147           0 :     if (mpViewShellBase != NULL
     148           0 :         && rxViewTabBarId->isBoundToURL(
     149           0 :             FrameworkHelper::msCenterPaneURL, AnchorBindingMode_DIRECT))
     150             :     {
     151           0 :         mpViewShellBase->SetViewTabBar(this);
     152           0 :     }
     153           0 : }
     154             : 
     155             : 
     156             : 
     157             : 
     158           0 : ViewTabBar::~ViewTabBar (void)
     159             : {
     160           0 : }
     161             : 
     162             : 
     163             : 
     164             : 
     165           0 : void ViewTabBar::disposing (void)
     166             : {
     167           0 :     if (mpViewShellBase != NULL
     168           0 :         && mxViewTabBarId->isBoundToURL(
     169           0 :             FrameworkHelper::msCenterPaneURL, AnchorBindingMode_DIRECT))
     170             :     {
     171           0 :         mpViewShellBase->SetViewTabBar(NULL);
     172             :     }
     173             : 
     174           0 :     if (mxConfigurationController.is())
     175             :     {
     176             :         // Unregister listener from XConfigurationController.
     177             :         try
     178             :         {
     179           0 :             mxConfigurationController->removeConfigurationChangeListener(this);
     180             :         }
     181           0 :         catch (const lang::DisposedException&)
     182             :         {
     183             :             // Receiving a disposed exception is the normal case.  Is there
     184             :             // a way to avoid it?
     185             :         }
     186           0 :         mxConfigurationController = NULL;
     187             :     }
     188             : 
     189             :     {
     190           0 :         const SolarMutexGuard aSolarGuard;
     191             :         // Set all references to the one tab page to NULL and delete the page.
     192           0 :         for (sal_uInt16 nIndex=0; nIndex<mpTabControl->GetPageCount(); ++nIndex)
     193           0 :             mpTabControl->SetTabPage(nIndex, NULL);
     194           0 :         mpTabPage.reset();
     195           0 :         mpTabControl.reset();
     196             :     }
     197             : 
     198           0 :     mxController = NULL;
     199           0 : }
     200             : 
     201             : 
     202             : 
     203             : 
     204           0 : ::boost::shared_ptr< ::TabControl> ViewTabBar::GetTabControl (void) const
     205             : {
     206           0 :     return mpTabControl;
     207             : }
     208             : 
     209             : 
     210             : 
     211             : 
     212           0 : ::Window* ViewTabBar::GetAnchorWindow(
     213             :     const Reference<XResourceId>& rxViewTabBarId,
     214             :     const Reference<frame::XController>& rxController)
     215             : {
     216           0 :     ::Window* pWindow = NULL;
     217           0 :     ViewShellBase* pBase = NULL;
     218             : 
     219             :     // Tunnel through the controller and use the ViewShellBase to obtain the
     220             :     // view frame.
     221             :     try
     222             :     {
     223           0 :         Reference<lang::XUnoTunnel> xTunnel (rxController, UNO_QUERY_THROW);
     224             :         DrawController* pController = reinterpret_cast<DrawController*>(
     225           0 :             xTunnel->getSomething(DrawController::getUnoTunnelId()));
     226           0 :         pBase = pController->GetViewShellBase();
     227             :     }
     228           0 :     catch (const RuntimeException&)
     229             :     {
     230             :     }
     231             : 
     232             :     // The ViewTabBar supports at the moment only the center pane.
     233           0 :     if (rxViewTabBarId.is()
     234           0 :         && rxViewTabBarId->isBoundToURL(
     235           0 :             FrameworkHelper::msCenterPaneURL, AnchorBindingMode_DIRECT))
     236             :     {
     237           0 :         if (pBase != NULL && pBase->GetViewFrame() != NULL)
     238           0 :             pWindow = &pBase->GetViewFrame()->GetWindow();
     239             :     }
     240             : 
     241             :     // The rest is (at the moment) just for the emergency case.
     242           0 :     if (pWindow == NULL)
     243             :     {
     244           0 :         Reference<XPane> xPane;
     245             :         try
     246             :         {
     247           0 :             Reference<XControllerManager> xControllerManager (rxController, UNO_QUERY_THROW);
     248             :             Reference<XConfigurationController> xCC (
     249           0 :                 xControllerManager->getConfigurationController());
     250           0 :             if (xCC.is())
     251           0 :                 xPane = Reference<XPane>(xCC->getResource(rxViewTabBarId->getAnchor()), UNO_QUERY);
     252             :         }
     253           0 :         catch (const RuntimeException&)
     254             :         {
     255             :         }
     256             : 
     257             :         // Tunnel through the XWindow to the VCL side.
     258             :         try
     259             :         {
     260           0 :             Reference<lang::XUnoTunnel> xTunnel (xPane, UNO_QUERY_THROW);
     261             :             framework::Pane* pPane = reinterpret_cast<framework::Pane*>(
     262           0 :                 xTunnel->getSomething(framework::Pane::getUnoTunnelId()));
     263           0 :             if (pPane != NULL)
     264           0 :                 pWindow = pPane->GetWindow()->GetParent();
     265             :         }
     266           0 :         catch (const RuntimeException&)
     267             :         {
     268           0 :         }
     269             :     }
     270             : 
     271           0 :     return pWindow;
     272             : }
     273             : 
     274             : 
     275             : 
     276             : 
     277             : //----- XConfigurationChangeListener ------------------------------------------
     278             : 
     279           0 : void SAL_CALL  ViewTabBar::notifyConfigurationChange (
     280             :     const ConfigurationChangeEvent& rEvent)
     281             :     throw (RuntimeException, std::exception)
     282             : {
     283           0 :     if (rEvent.Type.equals(FrameworkHelper::msResourceActivationEvent)
     284           0 :         && rEvent.ResourceId->getResourceURL().match(FrameworkHelper::msViewURLPrefix)
     285           0 :         && rEvent.ResourceId->isBoundTo(mxViewTabBarId->getAnchor(), AnchorBindingMode_DIRECT))
     286             :     {
     287           0 :         UpdateActiveButton();
     288             :     }
     289           0 : }
     290             : 
     291             : 
     292             : 
     293             : 
     294             : //----- XEventListener --------------------------------------------------------
     295             : 
     296           0 : void SAL_CALL ViewTabBar::disposing(
     297             :     const lang::EventObject& rEvent)
     298             :     throw (RuntimeException, std::exception)
     299             : {
     300           0 :     if (rEvent.Source == mxConfigurationController)
     301             :     {
     302           0 :         mxConfigurationController = NULL;
     303           0 :         mxController = NULL;
     304             :     }
     305           0 : }
     306             : 
     307             : 
     308             : 
     309             : 
     310             : //----- XTabBar ---------------------------------------------------------------
     311             : 
     312           0 : void SAL_CALL ViewTabBar::addTabBarButtonAfter (
     313             :     const TabBarButton& rButton,
     314             :     const TabBarButton& rAnchor)
     315             :     throw (::com::sun::star::uno::RuntimeException, std::exception)
     316             : {
     317           0 :     const SolarMutexGuard aSolarGuard;
     318           0 :     AddTabBarButton(rButton, rAnchor);
     319           0 : }
     320             : 
     321             : 
     322             : 
     323             : 
     324           0 : void SAL_CALL ViewTabBar::appendTabBarButton (const TabBarButton& rButton)
     325             :     throw (::com::sun::star::uno::RuntimeException, std::exception)
     326             : {
     327           0 :     const SolarMutexGuard aSolarGuard;
     328           0 :     AddTabBarButton(rButton);
     329           0 : }
     330             : 
     331             : 
     332             : 
     333           0 : void SAL_CALL ViewTabBar::removeTabBarButton (const TabBarButton& rButton)
     334             :     throw (::com::sun::star::uno::RuntimeException, std::exception)
     335             : {
     336           0 :     const SolarMutexGuard aSolarGuard;
     337           0 :     RemoveTabBarButton(rButton);
     338           0 : }
     339             : 
     340             : 
     341             : 
     342             : 
     343           0 : sal_Bool SAL_CALL ViewTabBar::hasTabBarButton (const TabBarButton& rButton)
     344             :     throw (::com::sun::star::uno::RuntimeException, std::exception)
     345             : {
     346           0 :     const SolarMutexGuard aSolarGuard;
     347           0 :     return HasTabBarButton(rButton);
     348             : }
     349             : 
     350             : 
     351             : 
     352             : 
     353           0 : Sequence<TabBarButton> SAL_CALL ViewTabBar::getTabBarButtons (void)
     354             :     throw (::com::sun::star::uno::RuntimeException, std::exception)
     355             : {
     356           0 :     const SolarMutexGuard aSolarGuard;
     357           0 :     return GetTabBarButtons();
     358             : }
     359             : 
     360             : 
     361             : 
     362             : 
     363             : //----- XResource -------------------------------------------------------------
     364             : 
     365           0 : Reference<XResourceId> SAL_CALL ViewTabBar::getResourceId (void)
     366             :     throw (RuntimeException, std::exception)
     367             : {
     368           0 :     return mxViewTabBarId;
     369             : }
     370             : 
     371             : 
     372             : 
     373             : 
     374           0 : sal_Bool SAL_CALL ViewTabBar::isAnchorOnly (void)
     375             :     throw (RuntimeException, std::exception)
     376             : {
     377           0 :     return false;
     378             : }
     379             : 
     380             : 
     381             : 
     382             : 
     383             : //----- XUnoTunnel ------------------------------------------------------------
     384             : 
     385             : namespace
     386             : {
     387             :     class theViewTabBarUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theViewTabBarUnoTunnelId > {};
     388             : }
     389             : 
     390           0 : const Sequence<sal_Int8>& ViewTabBar::getUnoTunnelId (void)
     391             : {
     392           0 :     return theViewTabBarUnoTunnelId::get().getSeq();
     393             : }
     394             : 
     395           0 : sal_Int64 SAL_CALL ViewTabBar::getSomething (const Sequence<sal_Int8>& rId)
     396             :     throw (RuntimeException, std::exception)
     397             : {
     398           0 :     sal_Int64 nResult = 0;
     399             : 
     400           0 :     if (rId.getLength() == 16
     401           0 :         && memcmp(getUnoTunnelId().getConstArray(), rId.getConstArray(), 16) == 0)
     402             :     {
     403           0 :         nResult = reinterpret_cast<sal_Int64>(this);
     404             :     }
     405             : 
     406           0 :     return nResult;
     407             : }
     408             : 
     409             : 
     410             : 
     411             : 
     412             : 
     413             : 
     414           0 : bool ViewTabBar::ActivatePage (void)
     415             : {
     416             :     try
     417             :     {
     418           0 :         Reference<XControllerManager> xControllerManager (mxController,UNO_QUERY_THROW);
     419             :         Reference<XConfigurationController> xConfigurationController (
     420           0 :             xControllerManager->getConfigurationController());
     421           0 :         if ( ! xConfigurationController.is())
     422           0 :             throw RuntimeException();
     423           0 :         Reference<XView> xView;
     424             :         try
     425             :         {
     426           0 :             xView = Reference<XView>(xConfigurationController->getResource(
     427             :                 ResourceId::create(
     428             :                     ::comphelper::getProcessComponentContext(),
     429           0 :                     FrameworkHelper::msCenterPaneURL)),
     430           0 :                 UNO_QUERY);
     431             :         }
     432           0 :         catch (const DeploymentException&)
     433             :         {
     434             :         }
     435             : 
     436           0 :         Client* pIPClient = NULL;
     437           0 :         if (mpViewShellBase != NULL)
     438           0 :             pIPClient = dynamic_cast<Client*>(mpViewShellBase->GetIPClient());
     439           0 :         if (pIPClient==NULL || ! pIPClient->IsObjectInPlaceActive())
     440             :         {
     441           0 :             sal_uInt16 nIndex (mpTabControl->GetCurPageId() - 1);
     442           0 :             if (nIndex < maTabBarButtons.size())
     443             :             {
     444           0 :                 xConfigurationController->requestResourceActivation(
     445           0 :                     maTabBarButtons[nIndex].ResourceId,
     446           0 :                     ResourceActivationMode_REPLACE);
     447             :             }
     448             : 
     449           0 :             return true;
     450             :         }
     451             :         else
     452             :         {
     453             :             // When we run into this else branch then we have an active OLE
     454             :             // object.  We ignore the request to switch views.  Additionally
     455             :             // we put the active tab back to the one for the current view.
     456           0 :             UpdateActiveButton();
     457           0 :         }
     458             :     }
     459           0 :     catch (const RuntimeException&)
     460             :     {
     461             :         DBG_UNHANDLED_EXCEPTION();
     462             :     }
     463             : 
     464           0 :     return false;
     465             : }
     466             : 
     467             : 
     468             : 
     469             : 
     470           0 : int ViewTabBar::GetHeight (void)
     471             : {
     472           0 :     int nHeight (0);
     473             : 
     474           0 :     if (!maTabBarButtons.empty())
     475             :     {
     476             :         TabPage* pActivePage (mpTabControl->GetTabPage(
     477           0 :             mpTabControl->GetCurPageId()));
     478           0 :         if (pActivePage!=NULL && mpTabControl->IsReallyVisible())
     479           0 :             nHeight = pActivePage->GetPosPixel().Y();
     480             : 
     481           0 :         if (nHeight <= 0)
     482             :             // Using a default when the real height can not be determined.
     483             :             // To get correct height this method should be called when the
     484             :             // control is visible.
     485           0 :             nHeight = 21;
     486             :     }
     487             : 
     488           0 :     return nHeight;
     489             : }
     490             : 
     491             : 
     492             : 
     493             : 
     494           0 : void ViewTabBar::AddTabBarButton (
     495             :     const ::com::sun::star::drawing::framework::TabBarButton& rButton,
     496             :     const ::com::sun::star::drawing::framework::TabBarButton& rAnchor)
     497             : {
     498             :     sal_uInt32 nIndex;
     499             : 
     500           0 :     if ( ! rAnchor.ResourceId.is()
     501           0 :         || (rAnchor.ResourceId->getResourceURL().isEmpty()
     502           0 :             && rAnchor.ButtonLabel.isEmpty()))
     503             :     {
     504           0 :         nIndex = 0;
     505             :     }
     506             :     else
     507             :     {
     508           0 :         for (nIndex=0; nIndex<maTabBarButtons.size(); ++nIndex)
     509             :         {
     510           0 :             if (IsEqual(maTabBarButtons[nIndex], rAnchor))
     511             :             {
     512           0 :                 ++nIndex;
     513           0 :                 break;
     514             :             }
     515             :         }
     516             :     }
     517             : 
     518           0 :     AddTabBarButton(rButton,nIndex);
     519           0 : }
     520             : 
     521             : 
     522             : 
     523             : 
     524           0 : void ViewTabBar::AddTabBarButton (
     525             :     const ::com::sun::star::drawing::framework::TabBarButton& rButton)
     526             : {
     527           0 :     AddTabBarButton(rButton, maTabBarButtons.size());
     528           0 : }
     529             : 
     530             : 
     531             : 
     532             : 
     533           0 : void ViewTabBar::AddTabBarButton (
     534             :     const ::com::sun::star::drawing::framework::TabBarButton& rButton,
     535             :     sal_Int32 nPosition)
     536             : {
     537           0 :     if (nPosition>=0
     538           0 :         && nPosition<=mpTabControl->GetPageCount())
     539             :     {
     540           0 :         sal_uInt16 nIndex ((sal_uInt16)nPosition);
     541             : 
     542             :         // Insert the button into our local array.
     543           0 :         maTabBarButtons.insert(maTabBarButtons.begin()+nIndex, rButton);
     544           0 :         UpdateTabBarButtons();
     545           0 :         UpdateActiveButton();
     546             :     }
     547           0 : }
     548             : 
     549             : 
     550             : 
     551             : 
     552           0 : void ViewTabBar::RemoveTabBarButton (
     553             :     const ::com::sun::star::drawing::framework::TabBarButton& rButton)
     554             : {
     555             :     sal_uInt16 nIndex;
     556           0 :     for (nIndex=0; nIndex<maTabBarButtons.size(); ++nIndex)
     557             :     {
     558           0 :         if (IsEqual(maTabBarButtons[nIndex], rButton))
     559             :         {
     560           0 :             maTabBarButtons.erase(maTabBarButtons.begin()+nIndex);
     561           0 :             UpdateTabBarButtons();
     562           0 :             UpdateActiveButton();
     563           0 :             break;
     564             :         }
     565             :     }
     566           0 : }
     567             : 
     568             : 
     569             : 
     570             : 
     571           0 : bool ViewTabBar::HasTabBarButton (
     572             :     const ::com::sun::star::drawing::framework::TabBarButton& rButton)
     573             : {
     574           0 :     bool bResult (false);
     575             : 
     576           0 :     for (sal_uInt32 nIndex=0; nIndex<maTabBarButtons.size(); ++nIndex)
     577             :     {
     578           0 :         if (IsEqual(maTabBarButtons[nIndex], rButton))
     579             :         {
     580           0 :             bResult = true;
     581           0 :             break;
     582             :         }
     583             :     }
     584             : 
     585           0 :     return bResult;
     586             : }
     587             : 
     588             : 
     589             : 
     590             : 
     591             : ::com::sun::star::uno::Sequence<com::sun::star::drawing::framework::TabBarButton>
     592           0 :     ViewTabBar::GetTabBarButtons (void)
     593             : {
     594           0 :     sal_uInt32 nCount (maTabBarButtons.size());
     595             :     ::com::sun::star::uno::Sequence<com::sun::star::drawing::framework::TabBarButton>
     596           0 :           aList (nCount);
     597             : 
     598           0 :     for (sal_uInt32 nIndex=0; nIndex<nCount; ++nIndex)
     599           0 :         aList[nIndex] = maTabBarButtons[nIndex];
     600             : 
     601           0 :     return aList;
     602             : }
     603             : 
     604             : 
     605             : 
     606             : 
     607           0 : void ViewTabBar::UpdateActiveButton (void)
     608             : {
     609           0 :     Reference<XView> xView;
     610           0 :     if (mpViewShellBase != NULL)
     611           0 :         xView = FrameworkHelper::Instance(*mpViewShellBase)->GetView(
     612           0 :             mxViewTabBarId->getAnchor());
     613           0 :     if (xView.is())
     614             :     {
     615           0 :         Reference<XResourceId> xViewId (xView->getResourceId());
     616           0 :         for (sal_uInt16 nIndex=0; nIndex<maTabBarButtons.size(); ++nIndex)
     617             :         {
     618           0 :             if (maTabBarButtons[nIndex].ResourceId->compareTo(xViewId) == 0)
     619             :             {
     620           0 :                 mpTabControl->SetCurPageId(nIndex+1);
     621           0 :                 mpTabControl->::TabControl::ActivatePage();
     622           0 :                 break;
     623             :             }
     624           0 :         }
     625           0 :     }
     626           0 : }
     627             : 
     628             : 
     629             : 
     630             : 
     631           0 : void ViewTabBar::UpdateTabBarButtons (void)
     632             : {
     633           0 :     TabBarButtonList::const_iterator iTab;
     634           0 :     sal_uInt16 nPageCount (mpTabControl->GetPageCount());
     635             :     sal_uInt16 nIndex;
     636           0 :     for (iTab=maTabBarButtons.begin(),nIndex=1; iTab!=maTabBarButtons.end(); ++iTab,++nIndex)
     637             :     {
     638             :         // Create a new tab when there are not enough.
     639           0 :         if (nPageCount < nIndex)
     640           0 :             mpTabControl->InsertPage(nIndex, iTab->ButtonLabel);
     641             : 
     642             :         // Update the tab.
     643           0 :         mpTabControl->SetPageText(nIndex, iTab->ButtonLabel);
     644           0 :         mpTabControl->SetHelpText(nIndex, iTab->HelpText);
     645           0 :         mpTabControl->SetTabPage(nIndex, mpTabPage.get());
     646             :     }
     647             : 
     648             :     // Delete tabs that are no longer used.
     649           0 :     for (; nIndex<=nPageCount; ++nIndex)
     650           0 :         mpTabControl->RemovePage(nIndex);
     651             : 
     652           0 :     mpTabPage->Hide();
     653           0 : }
     654             : 
     655             : 
     656             : 
     657             : 
     658             : //===== TabBarControl =========================================================
     659             : 
     660           0 : TabBarControl::TabBarControl (
     661             :     ::Window* pParentWindow,
     662             :     const ::rtl::Reference<ViewTabBar>& rpViewTabBar)
     663             :     : ::TabControl(pParentWindow),
     664           0 :       mpViewTabBar(rpViewTabBar)
     665             : {
     666           0 : }
     667             : 
     668             : 
     669             : 
     670             : 
     671           0 : void TabBarControl::Paint (const Rectangle& rRect)
     672             : {
     673           0 :     Color aOriginalFillColor (GetFillColor());
     674           0 :     Color aOriginalLineColor (GetLineColor());
     675             : 
     676             :     // Because the actual window background is transparent--to avoid
     677             :     // flickering due to multiple background paintings by this and by child
     678             :     // windows--we have to paint the background for this control explicitly:
     679             :     // the actual control is not painted over its whole bounding box.
     680           0 :     SetFillColor (GetSettings().GetStyleSettings().GetDialogColor());
     681           0 :     SetLineColor ();
     682           0 :     DrawRect (rRect);
     683           0 :     ::TabControl::Paint (rRect);
     684             : 
     685           0 :     SetFillColor (aOriginalFillColor);
     686           0 :     SetLineColor (aOriginalLineColor);
     687           0 : }
     688             : 
     689             : 
     690             : 
     691             : 
     692           0 : void TabBarControl::ActivatePage (void)
     693             : {
     694           0 :     if (mpViewTabBar->ActivatePage())
     695             :     {
     696             :         // Call the parent so that the correct tab is highlighted.
     697           0 :         this->::TabControl::ActivatePage();
     698             :     }
     699           0 : }
     700             : 
     701             : } // end of namespace sd
     702             : 
     703             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10