LCOV - code coverage report
Current view: top level - sdext/source/presenter - PresenterToolBar.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 1 823 0.1 %
Date: 2014-11-03 Functions: 2 134 1.5 %
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             : #include "vcl/svapp.hxx"
      21             : #include "vcl/settings.hxx"
      22             : #include "PresenterToolBar.hxx"
      23             : 
      24             : #include "PresenterBitmapContainer.hxx"
      25             : #include "PresenterCanvasHelper.hxx"
      26             : #include "PresenterGeometryHelper.hxx"
      27             : #include "PresenterPaintManager.hxx"
      28             : #include "PresenterPaneBase.hxx"
      29             : #include "PresenterPaneFactory.hxx"
      30             : #include "PresenterTimer.hxx"
      31             : #include "PresenterWindowManager.hxx"
      32             : 
      33             : #include <cppuhelper/compbase2.hxx>
      34             : #include <com/sun/star/awt/FontDescriptor.hpp>
      35             : #include <com/sun/star/awt/PosSize.hpp>
      36             : #include <com/sun/star/awt/XWindowPeer.hpp>
      37             : #include <com/sun/star/deployment/XPackageInformationProvider.hpp>
      38             : #include <com/sun/star/drawing/framework/XControllerManager.hpp>
      39             : #include <com/sun/star/drawing/framework/XConfigurationController.hpp>
      40             : #include <com/sun/star/drawing/framework/XPane.hpp>
      41             : #include <com/sun/star/geometry/AffineMatrix2D.hpp>
      42             : #include <com/sun/star/lang/XServiceName.hpp>
      43             : #include <com/sun/star/rendering/CompositeOperation.hpp>
      44             : #include <com/sun/star/rendering/RenderState.hpp>
      45             : #include <com/sun/star/rendering/TextDirection.hpp>
      46             : #include <com/sun/star/rendering/ViewState.hpp>
      47             : #include <com/sun/star/rendering/XSpriteCanvas.hpp>
      48             : #include <com/sun/star/text/XTextRange.hpp>
      49             : #include <com/sun/star/util/Color.hpp>
      50             : #include <com/sun/star/util/XURLTransformer.hpp>
      51             : #include <rtl/ustrbuf.hxx>
      52             : #include <boost/bind.hpp>
      53             : 
      54             : using namespace ::com::sun::star;
      55             : using namespace ::com::sun::star::uno;
      56             : using namespace ::com::sun::star::drawing::framework;
      57             : 
      58             : namespace sdext { namespace presenter {
      59             : 
      60             : static const sal_Int32 gnGapSize (20);
      61             : static const sal_Int32 gnMinimalSeparatorSize (20);
      62             : static const sal_Int32 gnSeparatorInset (0);
      63             : 
      64             : namespace {
      65             : 
      66           0 :     class Text
      67             :     {
      68             :     public:
      69             :         Text (void);
      70             :         Text (
      71             :             const OUString& rsText,
      72             :             const PresenterTheme::SharedFontDescriptor& rpFont);
      73             : 
      74             :         void SetText (const OUString& rsText);
      75             :         OUString GetText (void) const;
      76             :         PresenterTheme::SharedFontDescriptor GetFont (void) const;
      77             : 
      78             :         void Paint (
      79             :             const Reference<rendering::XCanvas>& rxCanvas,
      80             :             const rendering::ViewState& rViewState,
      81             :             const awt::Rectangle& rBoundingBox,
      82             :             const awt::Point& rOffset);
      83             : 
      84             :         geometry::RealRectangle2D GetBoundingBox (
      85             :             const Reference<rendering::XCanvas>& rxCanvas);
      86             : 
      87             :     private:
      88             :         OUString msText;
      89             :         PresenterTheme::SharedFontDescriptor mpFont;
      90             :     };
      91             : 
      92           0 :     class ElementMode
      93             :         : private ::boost::noncopyable
      94             :     {
      95             :     public:
      96             :         ElementMode (void);
      97             : 
      98             :         SharedBitmapDescriptor mpIcon;
      99             :         OUString msAction;
     100             :         Text maText;
     101             : 
     102             :         void ReadElementMode (
     103             :             const Reference<beans::XPropertySet>& rxProperties,
     104             :             const OUString& rsModeName,
     105             :             ::boost::shared_ptr<ElementMode>& rpDefaultMode,
     106             :             ::sdext::presenter::PresenterToolBar::Context& rContext);
     107             :     };
     108             :     typedef ::boost::shared_ptr<ElementMode> SharedElementMode;
     109             : 
     110             : }  // end of anonymous namespace
     111             : 
     112           0 : class PresenterToolBar::Context
     113             :     : private ::boost::noncopyable
     114             : {
     115             : public:
     116             :     Reference<drawing::XPresenterHelper> mxPresenterHelper;
     117             :     css::uno::Reference<css::rendering::XCanvas> mxCanvas;
     118             : };
     119             : 
     120             : //===== PresenterToolBar::Element =============================================
     121             : 
     122             : namespace {
     123             :     typedef cppu::WeakComponentImplHelper2<
     124             :         css::document::XEventListener,
     125             :         css::frame::XStatusListener
     126             :         > ElementInterfaceBase;
     127             : 
     128             :     class Element
     129             :         : private ::cppu::BaseMutex,
     130             :           private ::boost::noncopyable,
     131             :           public ElementInterfaceBase
     132             :     {
     133             :     public:
     134             :         Element (const ::rtl::Reference<PresenterToolBar>& rpToolBar);
     135             :         virtual ~Element (void);
     136             : 
     137             :         virtual void SAL_CALL disposing (void) SAL_OVERRIDE;
     138             : 
     139             :         virtual void SetModes (
     140             :             const SharedElementMode& rpNormalMode,
     141             :             const SharedElementMode& rpMouseOverMode,
     142             :             const SharedElementMode& rpSelectedMode,
     143             :             const SharedElementMode& rpDisabledMode);
     144             :         virtual void CurrentSlideHasChanged (void);
     145             :         virtual void SetLocation (const awt::Point& rLocation);
     146             :         virtual void SetSize (const geometry::RealSize2D& rSize);
     147             :         virtual void Paint (
     148             :             const Reference<rendering::XCanvas>& rxCanvas,
     149             :             const rendering::ViewState& rViewState) = 0;
     150             :         awt::Size GetBoundingSize (
     151             :             const Reference<rendering::XCanvas>& rxCanvas);
     152             :         awt::Rectangle GetBoundingBox (void) const;
     153             :         virtual bool SetState (const bool bIsOver, const bool bIsPressed);
     154             :         virtual void Invalidate (const bool bSynchronous = true);
     155             :         virtual bool IsOutside (const awt::Rectangle& rBox);
     156             :         virtual bool IsFilling (void) const;
     157             :         void UpdateState (void);
     158             : 
     159             :         // lang::XEventListener
     160             : 
     161             :         virtual void SAL_CALL disposing (const css::lang::EventObject& rEvent)
     162             :             throw(css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     163             : 
     164             :         // document::XEventListener
     165             : 
     166             :         virtual void SAL_CALL notifyEvent (const css::document::EventObject& rEvent)
     167             :             throw(css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     168             : 
     169             :         // frame::XStatusListener
     170             : 
     171             :         virtual void SAL_CALL statusChanged (const css::frame::FeatureStateEvent& rEvent)
     172             :             throw(css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     173             : 
     174             :     protected:
     175             :         ::rtl::Reference<PresenterToolBar> mpToolBar;
     176             :         awt::Point maLocation;
     177             :         awt::Size maSize;
     178             :         SharedElementMode mpNormal;
     179             :         SharedElementMode mpMouseOver;
     180             :         SharedElementMode mpSelected;
     181             :         SharedElementMode mpDisabled;
     182             :         SharedElementMode mpMode;
     183             :         bool mbIsOver;
     184             :         bool mbIsPressed;
     185             :         bool mbIsSelected;
     186             : 
     187             :         virtual awt::Size CreateBoundingSize (
     188             :             const Reference<rendering::XCanvas>& rxCanvas) = 0;
     189             : 
     190           0 :         bool IsEnabled (void) const { return mbIsEnabled;}
     191             :     private:
     192             :         bool mbIsEnabled;
     193             :     };
     194             : 
     195             : } // end of anonymous namespace
     196             : 
     197           0 : class PresenterToolBar::ElementContainerPart
     198             :     : public ::std::vector<rtl::Reference<Element> >
     199             : {
     200             : };
     201             : 
     202             : //===== Button ================================================================
     203             : 
     204             : namespace {
     205             : 
     206             :     class Button : public Element
     207             :     {
     208             :     public:
     209             :         static ::rtl::Reference<Element> Create (
     210             :             const ::rtl::Reference<PresenterToolBar>& rpToolBar);
     211             : 
     212             :         virtual ~Button (void);
     213             :         virtual void SAL_CALL disposing (void) SAL_OVERRIDE;
     214             : 
     215             :         virtual void Paint (
     216             :             const Reference<rendering::XCanvas>& rxCanvas,
     217             :             const rendering::ViewState& rViewState) SAL_OVERRIDE;
     218             : 
     219             :         // lang::XEventListener
     220             : 
     221             :         virtual void SAL_CALL disposing (const css::lang::EventObject& rEvent)
     222             :             throw(css::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     223             : 
     224             :     protected:
     225             :         virtual awt::Size CreateBoundingSize (
     226             :             const Reference<rendering::XCanvas>& rxCanvas) SAL_OVERRIDE;
     227             : 
     228             :     private:
     229             :         bool mbIsListenerRegistered;
     230             : 
     231             :         Button (const ::rtl::Reference<PresenterToolBar>& rpToolBar);
     232             :         void Initialize (void);
     233             :         void PaintIcon (
     234             :             const Reference<rendering::XCanvas>& rxCanvas,
     235             :             const sal_Int32 nTextHeight,
     236             :             const rendering::ViewState& rViewState);
     237             :         PresenterBitmapDescriptor::Mode GetMode (void) const;
     238             :     };
     239             : 
     240             : //===== Label =================================================================
     241             : 
     242           0 :     class Label : public Element
     243             :     {
     244             :     public:
     245             :         Label (const ::rtl::Reference<PresenterToolBar>& rpToolBar);
     246             : 
     247             :         void SetText (const OUString& rsText);
     248             :         virtual void Paint (
     249             :             const Reference<rendering::XCanvas>& rxCanvas,
     250             :             const rendering::ViewState& rViewState) SAL_OVERRIDE;
     251             :         virtual bool SetState (const bool bIsOver, const bool bIsPressed) SAL_OVERRIDE;
     252             : 
     253             :     protected:
     254             :         virtual awt::Size CreateBoundingSize (
     255             :             const Reference<rendering::XCanvas>& rxCanvas) SAL_OVERRIDE;
     256             :     };
     257             : 
     258             : // Some specialized controls.
     259             : 
     260             :     class TimeFormatter
     261             :     {
     262             :     public:
     263             :         TimeFormatter (void);
     264             :         OUString FormatTime (const oslDateTime& rTime);
     265             :     private:
     266             :         bool mbIs24HourFormat;
     267             :         bool mbIsAmPmFormat;
     268             :         bool mbIsShowSeconds;
     269             :     };
     270             : 
     271           0 :     class TimeLabel : public Label
     272             :     {
     273             :     public:
     274             :         void ConnectToTimer (void);
     275             :         virtual void TimeHasChanged (const oslDateTime& rCurrentTime) = 0;
     276             :     protected:
     277             :         TimeLabel(const ::rtl::Reference<PresenterToolBar>& rpToolBar);
     278             :         using Element::disposing;
     279             :         virtual void SAL_CALL disposing (void) SAL_OVERRIDE;
     280             :     private:
     281             :         class Listener : public PresenterClockTimer::Listener
     282             :         {
     283             :         public:
     284           0 :             Listener (const ::rtl::Reference<TimeLabel>& rxLabel)
     285           0 :                 : mxLabel(rxLabel) {}
     286           0 :             virtual ~Listener (void) {}
     287           0 :             virtual void TimeHasChanged (const oslDateTime& rCurrentTime) SAL_OVERRIDE
     288           0 :             { if (mxLabel.is()) mxLabel->TimeHasChanged(rCurrentTime); }
     289             :         private:
     290             :             ::rtl::Reference<TimeLabel> mxLabel;
     291             :         };
     292             :         ::boost::shared_ptr<PresenterClockTimer::Listener> mpListener;
     293             :     };
     294             : 
     295             :     class CurrentTimeLabel : public TimeLabel
     296             :     {
     297             :     public:
     298             :         static ::rtl::Reference<Element> Create (
     299             :             const ::rtl::Reference<PresenterToolBar>& rpToolBar);
     300             :         virtual void SetModes (
     301             :             const SharedElementMode& rpNormalMode,
     302             :             const SharedElementMode& rpMouseOverMode,
     303             :             const SharedElementMode& rpSelectedMode,
     304             :             const SharedElementMode& rpDisabledMode) SAL_OVERRIDE;
     305             :     private:
     306             :         TimeFormatter maTimeFormatter;
     307             :         CurrentTimeLabel (const ::rtl::Reference<PresenterToolBar>& rpToolBar);
     308             :         virtual ~CurrentTimeLabel (void);
     309             :         virtual void TimeHasChanged (const oslDateTime& rCurrentTime) SAL_OVERRIDE;
     310             :     };
     311             : 
     312             :     class PresentationTimeLabel : public TimeLabel
     313             :     {
     314             :     public:
     315             :         static ::rtl::Reference<Element> Create (
     316             :             const ::rtl::Reference<PresenterToolBar>& rpToolBar);
     317             :         virtual void SetModes (
     318             :             const SharedElementMode& rpNormalMode,
     319             :             const SharedElementMode& rpMouseOverMode,
     320             :             const SharedElementMode& rpSelectedMode,
     321             :             const SharedElementMode& rpDisabledMode) SAL_OVERRIDE;
     322             :     private:
     323             :         TimeFormatter maTimeFormatter;
     324             :         TimeValue maStartTimeValue;
     325             :         PresentationTimeLabel (const ::rtl::Reference<PresenterToolBar>& rpToolBar);
     326             :         virtual ~PresentationTimeLabel (void);
     327             :         virtual void TimeHasChanged (const oslDateTime& rCurrentTime) SAL_OVERRIDE;
     328             :     };
     329             : 
     330           0 :     class VerticalSeparator : public Element
     331             :     {
     332             :     public:
     333             :         explicit VerticalSeparator (const ::rtl::Reference<PresenterToolBar>& rpToolBar);
     334             :         virtual void Paint (
     335             :             const Reference<rendering::XCanvas>& rxCanvas,
     336             :             const rendering::ViewState& rViewState) SAL_OVERRIDE;
     337             :         virtual bool IsFilling (void) const SAL_OVERRIDE;
     338             : 
     339             :     protected:
     340             :         virtual awt::Size CreateBoundingSize (
     341             :             const Reference<rendering::XCanvas>& rxCanvas) SAL_OVERRIDE;
     342             :     };
     343             : 
     344           0 :     class HorizontalSeparator : public Element
     345             :     {
     346             :     public:
     347             :         explicit HorizontalSeparator (const ::rtl::Reference<PresenterToolBar>& rpToolBar);
     348             :         virtual void Paint (
     349             :             const Reference<rendering::XCanvas>& rxCanvas,
     350             :             const rendering::ViewState& rViewState) SAL_OVERRIDE;
     351             :         virtual bool IsFilling (void) const SAL_OVERRIDE;
     352             : 
     353             :     protected:
     354             :         virtual awt::Size CreateBoundingSize (
     355             :             const Reference<rendering::XCanvas>& rxCanvas) SAL_OVERRIDE;
     356             :     };
     357             : } // end of anonymous namespace
     358             : 
     359             : //===== PresenterToolBar ======================================================
     360             : 
     361           0 : PresenterToolBar::PresenterToolBar (
     362             :     const Reference<XComponentContext>& rxContext,
     363             :     const css::uno::Reference<css::awt::XWindow>& rxWindow,
     364             :     const css::uno::Reference<css::rendering::XCanvas>& rxCanvas,
     365             :     const ::rtl::Reference<PresenterController>& rpPresenterController,
     366             :     const Anchor eAnchor)
     367             :     : PresenterToolBarInterfaceBase(m_aMutex),
     368             :       mxComponentContext(rxContext),
     369             :       maElementContainer(),
     370             :       mpCurrentContainerPart(),
     371             :       mxWindow(rxWindow),
     372             :       mxCanvas(rxCanvas),
     373             :       mxSlideShowController(),
     374             :       mxCurrentSlide(),
     375             :       mpPresenterController(rpPresenterController),
     376             :       mbIsLayoutPending(false),
     377             :       meAnchor(eAnchor),
     378             :       maBoundingBox(),
     379           0 :       maMinimalSize()
     380             : {
     381           0 : }
     382             : 
     383           0 : void PresenterToolBar::Initialize (
     384             :     const OUString& rsConfigurationPath)
     385             : {
     386             :     try
     387             :     {
     388           0 :         CreateControls(rsConfigurationPath);
     389             : 
     390           0 :         if (mxWindow.is())
     391             :         {
     392           0 :             mxWindow->addWindowListener(this);
     393           0 :             mxWindow->addPaintListener(this);
     394           0 :             mxWindow->addMouseListener(this);
     395           0 :             mxWindow->addMouseMotionListener(this);
     396             : 
     397           0 :             Reference<awt::XWindowPeer> xPeer (mxWindow, UNO_QUERY);
     398           0 :             if (xPeer.is())
     399           0 :                 xPeer->setBackground(util::Color(0xff000000));
     400             : 
     401           0 :             mxWindow->setVisible(sal_True);
     402             :         }
     403             : 
     404           0 :         mxSlideShowController = mpPresenterController->GetSlideShowController();
     405           0 :         UpdateSlideNumber();
     406           0 :         mbIsLayoutPending = true;
     407             :     }
     408           0 :     catch (RuntimeException&)
     409             :     {
     410           0 :         mpCurrentContainerPart.reset();
     411           0 :         maElementContainer.clear();
     412           0 :         throw;
     413             :     }
     414           0 : }
     415             : 
     416           0 : PresenterToolBar::~PresenterToolBar (void)
     417             : {
     418           0 : }
     419             : 
     420           0 : void SAL_CALL PresenterToolBar::disposing (void)
     421             : {
     422           0 :     if (mxWindow.is())
     423             :     {
     424           0 :         mxWindow->removeWindowListener(this);
     425           0 :         mxWindow->removePaintListener(this);
     426           0 :         mxWindow->removeMouseListener(this);
     427           0 :         mxWindow->removeMouseMotionListener(this);
     428           0 :         mxWindow = NULL;
     429             :     }
     430             : 
     431             :     // Dispose tool bar elements.
     432           0 :     ElementContainer::iterator iPart (maElementContainer.begin());
     433           0 :     ElementContainer::const_iterator iEnd (maElementContainer.end());
     434           0 :     for ( ; iPart!=iEnd; ++iPart)
     435             :     {
     436             :         OSL_ASSERT(iPart->get()!=NULL);
     437           0 :         ElementContainerPart::iterator iElement ((*iPart)->begin());
     438           0 :         ElementContainerPart::const_iterator iPartEnd ((*iPart)->end());
     439           0 :         for ( ; iElement!=iPartEnd; ++iElement)
     440             :         {
     441           0 :             if (iElement->get() != NULL)
     442             :             {
     443           0 :                 ::rtl::Reference<Element> pElement (*iElement);
     444             :                 Reference<lang::XComponent> xComponent (
     445           0 :                     static_cast<XWeak*>(pElement.get()), UNO_QUERY);
     446           0 :                 if (xComponent.is())
     447           0 :                     xComponent->dispose();
     448             :             }
     449             :         }
     450             :     }
     451             : 
     452           0 :     mpCurrentContainerPart.reset();
     453           0 :     maElementContainer.clear();
     454           0 : }
     455             : 
     456           0 : void PresenterToolBar::InvalidateArea (
     457             :     const awt::Rectangle& rRepaintBox,
     458             :     const bool bSynchronous)
     459             : {
     460           0 :     ::boost::shared_ptr<PresenterPaintManager> xManager(mpPresenterController->GetPaintManager());
     461           0 :     if (!xManager)
     462           0 :         return;
     463             :     xManager->Invalidate(
     464             :         mxWindow,
     465             :         rRepaintBox,
     466           0 :         bSynchronous);
     467             : }
     468             : 
     469           0 : void PresenterToolBar::RequestLayout (void)
     470             : {
     471           0 :     mbIsLayoutPending = true;
     472             : 
     473           0 :     ::boost::shared_ptr<PresenterPaintManager> xManager(mpPresenterController->GetPaintManager());
     474           0 :     if (!xManager)
     475           0 :         return;
     476             : 
     477           0 :     xManager->Invalidate(mxWindow);
     478             : }
     479             : 
     480           0 : geometry::RealSize2D PresenterToolBar::GetMinimalSize (void)
     481             : {
     482           0 :     if (mbIsLayoutPending)
     483           0 :         Layout(mxCanvas);
     484           0 :     return maMinimalSize;
     485             : }
     486             : 
     487           0 : ::rtl::Reference<PresenterController> PresenterToolBar::GetPresenterController (void) const
     488             : {
     489           0 :     return mpPresenterController;
     490             : }
     491             : 
     492           0 : Reference<XComponentContext> PresenterToolBar::GetComponentContext (void) const
     493             : {
     494           0 :     return mxComponentContext;
     495             : }
     496             : 
     497             : //-----  lang::XEventListener -------------------------------------------------
     498             : 
     499           0 : void SAL_CALL PresenterToolBar::disposing (const lang::EventObject& rEventObject)
     500             :     throw (RuntimeException, std::exception)
     501             : {
     502           0 :     if (rEventObject.Source == mxWindow)
     503           0 :         mxWindow = NULL;
     504           0 : }
     505             : 
     506             : //----- XWindowListener -------------------------------------------------------
     507             : 
     508           0 : void SAL_CALL PresenterToolBar::windowResized (const awt::WindowEvent& rEvent)
     509             :     throw (RuntimeException, std::exception)
     510             : {
     511             :     (void)rEvent;
     512           0 :     mbIsLayoutPending = true;
     513           0 : }
     514             : 
     515           0 : void SAL_CALL PresenterToolBar::windowMoved (const awt::WindowEvent& rEvent)
     516             :     throw (RuntimeException, std::exception)
     517             : {
     518             :     (void)rEvent;
     519           0 : }
     520             : 
     521           0 : void SAL_CALL PresenterToolBar::windowShown (const lang::EventObject& rEvent)
     522             :     throw (RuntimeException, std::exception)
     523             : {
     524             :     (void)rEvent;
     525           0 :     mbIsLayoutPending = true;
     526           0 : }
     527             : 
     528           0 : void SAL_CALL PresenterToolBar::windowHidden (const lang::EventObject& rEvent)
     529             :     throw (RuntimeException, std::exception)
     530             : {
     531             :     (void)rEvent;
     532           0 : }
     533             : 
     534             : //----- XPaintListener --------------------------------------------------------
     535           0 : void SAL_CALL PresenterToolBar::windowPaint (const css::awt::PaintEvent& rEvent)
     536             :     throw (RuntimeException, std::exception)
     537             : {
     538           0 :     if ( ! mxCanvas.is())
     539           0 :         return;
     540             : 
     541           0 :     if ( ! mbIsPresenterViewActive)
     542           0 :         return;
     543             : 
     544             :     const rendering::ViewState aViewState (
     545             :         geometry::AffineMatrix2D(1,0,0, 0,1,0),
     546           0 :         PresenterGeometryHelper::CreatePolygon(rEvent.UpdateRect, mxCanvas->getDevice()));
     547             : 
     548           0 :     if (mbIsLayoutPending)
     549           0 :         Layout(mxCanvas);
     550             : 
     551           0 :     Paint(rEvent.UpdateRect, aViewState);
     552             : 
     553             :     // Make the back buffer visible.
     554           0 :     Reference<rendering::XSpriteCanvas> xSpriteCanvas (mxCanvas, UNO_QUERY);
     555           0 :     if (xSpriteCanvas.is())
     556           0 :         xSpriteCanvas->updateScreen(sal_False);
     557             : }
     558             : 
     559             : //----- XMouseListener --------------------------------------------------------
     560           0 : void SAL_CALL PresenterToolBar::mousePressed (const css::awt::MouseEvent& rEvent)
     561             :     throw(css::uno::RuntimeException, std::exception)
     562             : {
     563           0 :         ThrowIfDisposed();
     564           0 :         CheckMouseOver(rEvent, true, true);
     565           0 : }
     566             : 
     567           0 : void SAL_CALL PresenterToolBar::mouseReleased (const css::awt::MouseEvent& rEvent)
     568             :     throw(css::uno::RuntimeException, std::exception)
     569             : {
     570           0 :         ThrowIfDisposed();
     571           0 :         CheckMouseOver(rEvent, true);
     572           0 : }
     573             : 
     574           0 : void SAL_CALL PresenterToolBar::mouseEntered (const css::awt::MouseEvent& rEvent)
     575             :     throw(css::uno::RuntimeException, std::exception)
     576             : {
     577           0 :         ThrowIfDisposed();
     578           0 :         CheckMouseOver(rEvent, true);
     579           0 : }
     580             : 
     581           0 : void SAL_CALL PresenterToolBar::mouseExited (const css::awt::MouseEvent& rEvent)
     582             :     throw(css::uno::RuntimeException, std::exception)
     583             : {
     584           0 :         ThrowIfDisposed();
     585           0 :         CheckMouseOver(rEvent, false);
     586           0 :  }
     587             : 
     588             : //----- XMouseMotionListener --------------------------------------------------
     589             : 
     590           0 : void SAL_CALL PresenterToolBar::mouseMoved (const css::awt::MouseEvent& rEvent)
     591             :     throw (css::uno::RuntimeException, std::exception)
     592             : {
     593           0 :         ThrowIfDisposed();
     594           0 :         CheckMouseOver(rEvent, true);
     595           0 :  }
     596             : 
     597           0 : void SAL_CALL PresenterToolBar::mouseDragged (const css::awt::MouseEvent& rEvent)
     598             :     throw (css::uno::RuntimeException, std::exception)
     599             : {
     600           0 :     ThrowIfDisposed();
     601             :     (void)rEvent;
     602           0 : }
     603             : 
     604             : //----- XDrawView -------------------------------------------------------------
     605             : 
     606           0 : void SAL_CALL PresenterToolBar::setCurrentPage (const Reference<drawing::XDrawPage>& rxSlide)
     607             :     throw (RuntimeException, std::exception)
     608             : {
     609           0 :     if (rxSlide != mxCurrentSlide)
     610             :     {
     611           0 :         mxCurrentSlide = rxSlide;
     612           0 :         UpdateSlideNumber();
     613             :     }
     614           0 : }
     615             : 
     616           0 : Reference<drawing::XDrawPage> SAL_CALL PresenterToolBar::getCurrentPage (void)
     617             :     throw (RuntimeException, std::exception)
     618             : {
     619           0 :     return mxCurrentSlide;
     620             : }
     621             : 
     622             : 
     623             : 
     624           0 : void PresenterToolBar::CreateControls (
     625             :     const OUString& rsConfigurationPath)
     626             : {
     627           0 :     if ( ! mxWindow.is())
     628           0 :         return;
     629             : 
     630             :     // Expand the macro in the bitmap file names.
     631             :     PresenterConfigurationAccess aConfiguration (
     632             :         mxComponentContext,
     633             :         OUString("/org.openoffice.Office.PresenterScreen/"),
     634           0 :         PresenterConfigurationAccess::READ_ONLY);
     635             : 
     636           0 :     mpCurrentContainerPart.reset(new ElementContainerPart());
     637           0 :     maElementContainer.clear();
     638           0 :     maElementContainer.push_back(mpCurrentContainerPart);
     639             : 
     640             :     Reference<container::XHierarchicalNameAccess> xToolBarNode (
     641             :         aConfiguration.GetConfigurationNode(rsConfigurationPath),
     642           0 :         UNO_QUERY);
     643           0 :     if (xToolBarNode.is())
     644             :     {
     645             :         Reference<container::XNameAccess> xEntries (
     646             :             PresenterConfigurationAccess::GetConfigurationNode(xToolBarNode, "Entries"),
     647           0 :             UNO_QUERY);
     648           0 :         Context aContext;
     649           0 :         aContext.mxPresenterHelper = mpPresenterController->GetPresenterHelper();
     650           0 :         aContext.mxCanvas = mxCanvas;
     651           0 :         if (xEntries.is()
     652           0 :             && aContext.mxPresenterHelper.is()
     653           0 :             && aContext.mxCanvas.is())
     654             :         {
     655             :             PresenterConfigurationAccess::ForAll(
     656             :                 xEntries,
     657           0 :                 ::boost::bind(&PresenterToolBar::ProcessEntry, this, _2, ::boost::ref(aContext)));
     658           0 :         }
     659           0 :     }
     660             : }
     661             : 
     662           0 : void PresenterToolBar::ProcessEntry (
     663             :     const Reference<beans::XPropertySet>& rxProperties,
     664             :     Context& rContext)
     665             : {
     666           0 :     if ( ! rxProperties.is())
     667           0 :         return;
     668             : 
     669             :     // Type has to be present.
     670           0 :     OUString sType;
     671           0 :     if ( ! (PresenterConfigurationAccess::GetProperty(rxProperties, "Type") >>= sType))
     672           0 :         return;
     673             : 
     674           0 :     OUString sName;
     675           0 :     PresenterConfigurationAccess::GetProperty(rxProperties, "Name") >>= sName;
     676             : 
     677             :     // Read mode specific values.
     678           0 :     SharedElementMode pNormalMode (new ElementMode());
     679           0 :     SharedElementMode pMouseOverMode (new ElementMode());
     680           0 :     SharedElementMode pSelectedMode (new ElementMode());
     681           0 :     SharedElementMode pDisabledMode (new ElementMode());
     682           0 :     pNormalMode->ReadElementMode(rxProperties, "Normal", pNormalMode, rContext);
     683           0 :     pMouseOverMode->ReadElementMode(rxProperties, "MouseOver", pNormalMode, rContext);
     684           0 :     pSelectedMode->ReadElementMode(rxProperties, "Selected", pNormalMode, rContext);
     685           0 :     pDisabledMode->ReadElementMode(rxProperties, "Disabled", pNormalMode, rContext);
     686             : 
     687             :     // Create new element.
     688           0 :     ::rtl::Reference<Element> pElement;
     689           0 :     if ( sType == "Button" )
     690           0 :         pElement = Button::Create(this);
     691           0 :     else if ( sType == "CurrentTimeLabel" )
     692           0 :         pElement = CurrentTimeLabel::Create(this);
     693           0 :     else if ( sType == "PresentationTimeLabel" )
     694           0 :         pElement = PresentationTimeLabel::Create(this);
     695           0 :     else if ( sType == "VerticalSeparator" )
     696           0 :         pElement = ::rtl::Reference<Element>(new VerticalSeparator(this));
     697           0 :     else if ( sType == "HorizontalSeparator" )
     698           0 :         pElement = ::rtl::Reference<Element>(new HorizontalSeparator(this));
     699           0 :     else if ( sType == "Label" )
     700           0 :         pElement = ::rtl::Reference<Element>(new Label(this));
     701           0 :     else if ( sType == "ChangeOrientation" )
     702             :     {
     703           0 :         mpCurrentContainerPart.reset(new ElementContainerPart());
     704           0 :         maElementContainer.push_back(mpCurrentContainerPart);
     705           0 :         return;
     706             :     }
     707           0 :     if (pElement.is())
     708             :     {
     709           0 :         pElement->SetModes( pNormalMode, pMouseOverMode, pSelectedMode, pDisabledMode);
     710           0 :         pElement->UpdateState();
     711           0 :         if (mpCurrentContainerPart.get() != NULL)
     712           0 :             mpCurrentContainerPart->push_back(pElement);
     713           0 :     }
     714             : }
     715             : 
     716           0 : void PresenterToolBar::Layout (
     717             :     const Reference<rendering::XCanvas>& rxCanvas)
     718             : {
     719           0 :     if (maElementContainer.empty())
     720           0 :         return;
     721             : 
     722           0 :     mbIsLayoutPending = false;
     723             : 
     724           0 :     const awt::Rectangle aWindowBox (mxWindow->getPosSize());
     725           0 :     ElementContainer::iterator iPart;
     726           0 :     ElementContainer::iterator iEnd (maElementContainer.end());
     727           0 :     ElementContainer::iterator iBegin (maElementContainer.begin());
     728           0 :     ::std::vector<geometry::RealSize2D> aPartSizes (maElementContainer.size());
     729           0 :     geometry::RealSize2D aTotalSize (0,0);
     730           0 :     bool bIsHorizontal (true);
     731             :     sal_Int32 nIndex;
     732           0 :     double nTotalHorizontalGap (0);
     733           0 :     sal_Int32 nGapCount (0);
     734           0 :     for (iPart=maElementContainer.begin(),nIndex=0; iPart!=iEnd; ++iPart,++nIndex)
     735             :     {
     736           0 :         geometry::RealSize2D aSize (CalculatePartSize(rxCanvas, *iPart, bIsHorizontal));
     737             : 
     738             :         // Remember the size of each part for later.
     739           0 :         aPartSizes[nIndex] = aSize;
     740             : 
     741             :         // Add gaps between elements.
     742           0 :         if ((*iPart)->size()>1 && bIsHorizontal)
     743             :         {
     744           0 :             nTotalHorizontalGap += ((*iPart)->size() - 1) * gnGapSize;
     745           0 :             nGapCount += (*iPart)->size()-1;
     746             :         }
     747             : 
     748             :         // Orientation changes for each part.
     749           0 :         bIsHorizontal = !bIsHorizontal;
     750             :         // Width is accumulated.
     751           0 :         aTotalSize.Width += aSize.Width;
     752             :         // Height is the maximum height of all parts.
     753           0 :         aTotalSize.Height = ::std::max(aTotalSize.Height, aSize.Height);
     754             :     }
     755             :     // Add gaps between parts.
     756           0 :     if (maElementContainer.size() > 1)
     757             :     {
     758           0 :         nTotalHorizontalGap += (maElementContainer.size() - 1) * gnGapSize;
     759           0 :         nGapCount += maElementContainer.size()-1;
     760             :     }
     761             : 
     762             :     // Calculate the minimal size so that the window size of the tool bar
     763             :     // can be adapted accordingly.
     764           0 :     maMinimalSize = aTotalSize;
     765           0 :     maMinimalSize.Width += nTotalHorizontalGap;
     766             : 
     767             :     // Calculate the gaps between elements.
     768           0 :     double nGapWidth (0);
     769           0 :     if (nGapCount > 0)
     770             :     {
     771           0 :         if (aTotalSize.Width + nTotalHorizontalGap > aWindowBox.Width)
     772           0 :             nTotalHorizontalGap = aWindowBox.Width - aTotalSize.Width;
     773           0 :         nGapWidth = nTotalHorizontalGap / nGapCount;
     774             :     }
     775             : 
     776             :     // Determine the location of the left edge.
     777           0 :     double nX (0);
     778           0 :     switch (meAnchor)
     779             :     {
     780           0 :         case Left : nX = 0; break;
     781           0 :         case Center: nX = (aWindowBox.Width - aTotalSize.Width - nTotalHorizontalGap) / 2; break;
     782           0 :         case Right: nX = aWindowBox.Width - aTotalSize.Width - nTotalHorizontalGap; break;
     783             :     }
     784             : 
     785             :     // Place the parts.
     786           0 :     double nY ((aWindowBox.Height - aTotalSize.Height) / 2);
     787           0 :     bIsHorizontal = true;
     788             : 
     789           0 :     maBoundingBox.X1 = nX;
     790           0 :     maBoundingBox.Y1 = nY;
     791           0 :     maBoundingBox.X2 = nX + aTotalSize.Width + nTotalHorizontalGap;
     792           0 :     maBoundingBox.Y2 = nY + aTotalSize.Height;
     793             : 
     794             :     /* push front or back ? ... */
     795             :     /// check whether RTL interface or not
     796           0 :     if(!Application::GetSettings().GetLayoutRTL()){
     797           0 :         for (iPart=maElementContainer.begin(), nIndex=0; iPart!=iEnd; ++iPart,++nIndex)
     798             :         {
     799             :             geometry::RealRectangle2D aBoundingBox(
     800             :                 nX, nY,
     801           0 :                 nX+aPartSizes[nIndex].Width, nY+aTotalSize.Height);
     802             : 
     803             :             // Add space for gaps between elements.
     804           0 :             if ((*iPart)->size() > 1)
     805           0 :                 if (bIsHorizontal)
     806           0 :                     aBoundingBox.X2 += ((*iPart)->size()-1) * nGapWidth;
     807             : 
     808           0 :             LayoutPart(rxCanvas, *iPart, aBoundingBox, aPartSizes[nIndex], bIsHorizontal);
     809           0 :             bIsHorizontal = !bIsHorizontal;
     810           0 :             nX += aBoundingBox.X2 - aBoundingBox.X1 + nGapWidth;
     811             :         }
     812             :     }
     813             :     else {
     814           0 :         for (iPart=maElementContainer.end()-1, nIndex=2; iPart!=iBegin-1; --iPart, --nIndex)
     815             :         {
     816             :             geometry::RealRectangle2D aBoundingBox(
     817             :                 nX, nY,
     818           0 :                 nX+aPartSizes[nIndex].Width, nY+aTotalSize.Height);
     819             : 
     820             :             // Add space for gaps between elements.
     821           0 :             if ((*iPart)->size() > 1)
     822           0 :                 if (bIsHorizontal)
     823           0 :                     aBoundingBox.X2 += ((*iPart)->size()-1) * nGapWidth;
     824             : 
     825           0 :             LayoutPart(rxCanvas, *iPart, aBoundingBox, aPartSizes[nIndex], bIsHorizontal);
     826           0 :             bIsHorizontal = !bIsHorizontal;
     827           0 :             nX += aBoundingBox.X2 - aBoundingBox.X1 + nGapWidth;
     828             :         }
     829             :     }
     830             : 
     831             :     // The whole window has to be repainted.
     832           0 :     ::boost::shared_ptr<PresenterPaintManager> xManager(mpPresenterController->GetPaintManager());
     833           0 :     if (!xManager)
     834           0 :         return;
     835           0 :     xManager->Invalidate(mxWindow);
     836             : }
     837             : 
     838           0 : geometry::RealSize2D PresenterToolBar::CalculatePartSize (
     839             :     const Reference<rendering::XCanvas>& rxCanvas,
     840             :     const SharedElementContainerPart& rpPart,
     841             :     const bool bIsHorizontal)
     842             : {
     843           0 :     geometry::RealSize2D aTotalSize (0,0);
     844             : 
     845           0 :     if (mxWindow.is())
     846             :     {
     847             :         // Calculate the summed width of all elements.
     848           0 :         ElementContainerPart::const_iterator iElement;
     849           0 :         for (iElement=rpPart->begin(); iElement!=rpPart->end(); ++iElement)
     850             :         {
     851           0 :             if (iElement->get() == NULL)
     852           0 :                 continue;
     853             : 
     854           0 :             const awt::Size aBSize ((*iElement)->GetBoundingSize(rxCanvas));
     855           0 :             if (bIsHorizontal)
     856             :             {
     857           0 :                 aTotalSize.Width += aBSize.Width;
     858           0 :                 if (aBSize.Height > aTotalSize.Height)
     859           0 :                     aTotalSize.Height = aBSize.Height;
     860             :             }
     861             :             else
     862             :             {
     863           0 :                 aTotalSize.Height += aBSize.Height;
     864           0 :                 if (aBSize.Width > aTotalSize.Width)
     865           0 :                     aTotalSize.Width = aBSize.Width;
     866             :             }
     867             :         }
     868             :     }
     869           0 :     return aTotalSize;
     870             : }
     871             : 
     872           0 : void PresenterToolBar::LayoutPart (
     873             :     const Reference<rendering::XCanvas>& rxCanvas,
     874             :     const SharedElementContainerPart& rpPart,
     875             :     const geometry::RealRectangle2D& rBoundingBox,
     876             :     const geometry::RealSize2D& rPartSize,
     877             :     const bool bIsHorizontal)
     878             : {
     879           0 :     double nGap (0);
     880           0 :     if (rpPart->size() > 1)
     881             :     {
     882           0 :         if (bIsHorizontal)
     883           0 :             nGap = (rBoundingBox.X2 - rBoundingBox.X1 - rPartSize.Width) / (rpPart->size()-1);
     884             :         else
     885           0 :             nGap = (rBoundingBox.Y2 - rBoundingBox.Y1 - rPartSize.Height) / (rpPart->size()-1);
     886             :     }
     887             : 
     888             :     // Place the elements.
     889           0 :     double nX (rBoundingBox.X1);
     890           0 :     double nY (rBoundingBox.Y1);
     891             : 
     892           0 :     ElementContainerPart::const_iterator iElement;
     893           0 :     ElementContainerPart::const_iterator iEnd (rpPart->end());
     894           0 :     ElementContainerPart::const_iterator iBegin (rpPart->begin());
     895             : 
     896             :     /// check whether RTL interface or not
     897           0 :     if(!Application::GetSettings().GetLayoutRTL()){
     898           0 :         for (iElement=rpPart->begin(); iElement!=iEnd; ++iElement)
     899             :         {
     900           0 :             if (iElement->get() == NULL)
     901           0 :                 continue;
     902             : 
     903           0 :             const awt::Size aElementSize ((*iElement)->GetBoundingSize(rxCanvas));
     904           0 :             if (bIsHorizontal)
     905             :             {
     906           0 :                 if ((*iElement)->IsFilling())
     907             :                 {
     908           0 :                     nY = rBoundingBox.Y1;
     909           0 :                     (*iElement)->SetSize(geometry::RealSize2D(aElementSize.Width, rBoundingBox.Y2 - rBoundingBox.Y1));
     910             :                 }
     911             :                 else
     912           0 :                     nY = rBoundingBox.Y1 + (rBoundingBox.Y2-rBoundingBox.Y1 - aElementSize.Height) / 2;
     913           0 :                 (*iElement)->SetLocation(awt::Point(sal_Int32(0.5 + nX), sal_Int32(0.5 + nY)));
     914           0 :                 nX += aElementSize.Width + nGap;
     915             :             }
     916             :             else
     917             :             {
     918           0 :                 if ((*iElement)->IsFilling())
     919             :                 {
     920           0 :                     nX = rBoundingBox.X1;
     921           0 :                     (*iElement)->SetSize(geometry::RealSize2D(rBoundingBox.X2 - rBoundingBox.X1, aElementSize.Height));
     922             :                 }
     923             :                 else
     924           0 :                     nX = rBoundingBox.X1 + (rBoundingBox.X2-rBoundingBox.X1 - aElementSize.Width) / 2;
     925           0 :                 (*iElement)->SetLocation(awt::Point(sal_Int32(0.5 + nX), sal_Int32(0.5 + nY)));
     926           0 :                 nY += aElementSize.Height + nGap;
     927             :             }
     928             :         }
     929             :     }
     930             :     else {
     931           0 :         for (iElement=rpPart->end()-1; iElement!=iBegin-1; --iElement)
     932             :         {
     933           0 :             if (iElement->get() == NULL)
     934           0 :                 continue;
     935             : 
     936           0 :             const awt::Size aElementSize ((*iElement)->GetBoundingSize(rxCanvas));
     937           0 :             if (bIsHorizontal)
     938             :             {
     939           0 :                 if ((*iElement)->IsFilling())
     940             :                 {
     941           0 :                     nY = rBoundingBox.Y1;
     942           0 :                     (*iElement)->SetSize(geometry::RealSize2D(aElementSize.Width, rBoundingBox.Y2 - rBoundingBox.Y1));
     943             :                 }
     944             :                 else
     945           0 :                     nY = rBoundingBox.Y1 + (rBoundingBox.Y2-rBoundingBox.Y1 - aElementSize.Height) / 2;
     946           0 :                 (*iElement)->SetLocation(awt::Point(sal_Int32(0.5 + nX), sal_Int32(0.5 + nY)));
     947           0 :                 nX += aElementSize.Width + nGap;
     948             :             }
     949             :             else
     950             :             {
     951             :                 // reverse presentation time with current time
     952           0 :                 if (iElement==iBegin){
     953           0 :                     iElement=iBegin+2;
     954             :                 }
     955           0 :                 else if (iElement==iBegin+2){
     956           0 :                     iElement=iBegin;
     957             :                 }
     958           0 :                 const awt::Size aNewElementSize ((*iElement)->GetBoundingSize(rxCanvas));
     959           0 :                 if ((*iElement)->IsFilling())
     960             :                 {
     961           0 :                     nX = rBoundingBox.X1;
     962           0 :                     (*iElement)->SetSize(geometry::RealSize2D(rBoundingBox.X2 - rBoundingBox.X1, aNewElementSize.Height));
     963             :                 }
     964             :                 else
     965           0 :                     nX = rBoundingBox.X1 + (rBoundingBox.X2-rBoundingBox.X1 - aNewElementSize.Width) / 2;
     966           0 :                 (*iElement)->SetLocation(awt::Point(sal_Int32(0.5 + nX), sal_Int32(0.5 + nY)));
     967           0 :                 nY += aNewElementSize.Height + nGap;
     968             : 
     969             :                 // return the index as it was before the reversing
     970           0 :                 if (iElement==iBegin)
     971           0 :                     iElement=iBegin+2;
     972           0 :                 else if (iElement==iBegin+2)
     973           0 :                     iElement=iBegin;
     974             :             }
     975             :         }
     976             :     }
     977             : 
     978           0 : }
     979             : 
     980           0 : void PresenterToolBar::Paint (
     981             :     const awt::Rectangle& rUpdateBox,
     982             :     const rendering::ViewState& rViewState)
     983             : {
     984             :     OSL_ASSERT(mxCanvas.is());
     985             : 
     986           0 :     ElementContainer::iterator iPart;
     987           0 :     ElementContainer::const_iterator iEnd (maElementContainer.end());
     988           0 :     for (iPart=maElementContainer.begin(); iPart!=iEnd; ++iPart)
     989             :     {
     990           0 :         ElementContainerPart::iterator iElement;
     991           0 :         ElementContainerPart::const_iterator iPartEnd ((*iPart)->end());
     992           0 :         for (iElement=(*iPart)->begin(); iElement!=iPartEnd; ++iElement)
     993             :         {
     994           0 :             if (iElement->get() != NULL)
     995             :             {
     996           0 :                 if ( ! (*iElement)->IsOutside(rUpdateBox))
     997           0 :                     (*iElement)->Paint(mxCanvas, rViewState);
     998             :             }
     999             :         }
    1000             :     }
    1001           0 : }
    1002             : 
    1003           0 : void PresenterToolBar::UpdateSlideNumber (void)
    1004             : {
    1005           0 :     if( mxSlideShowController.is() )
    1006             :     {
    1007           0 :         ElementContainer::iterator iPart;
    1008           0 :         ElementContainer::const_iterator iEnd (maElementContainer.end());
    1009           0 :         for (iPart=maElementContainer.begin(); iPart!=iEnd; ++iPart)
    1010             :         {
    1011           0 :             ElementContainerPart::iterator iElement;
    1012           0 :             ElementContainerPart::const_iterator iPartEnd ((*iPart)->end());
    1013           0 :             for (iElement=(*iPart)->begin(); iElement!=iPartEnd; ++iElement)
    1014             :             {
    1015           0 :                 if (iElement->get() != NULL)
    1016           0 :                     (*iElement)->CurrentSlideHasChanged();
    1017             :             }
    1018             :         }
    1019             :     }
    1020           0 : }
    1021             : 
    1022           0 : void PresenterToolBar::CheckMouseOver (
    1023             :     const css::awt::MouseEvent& rEvent,
    1024             :     const bool bOverWindow,
    1025             :     const bool bMouseDown)
    1026             : {
    1027           0 :     css::awt::MouseEvent rTemp =rEvent;
    1028           0 :     if(Application::GetSettings().GetLayoutRTL()){
    1029           0 :         awt::Rectangle aWindowBox = mxWindow->getPosSize();
    1030           0 :         rTemp.X=aWindowBox.Width-rTemp.X;
    1031             :     }
    1032           0 :     ElementContainer::iterator iPart;
    1033           0 :     ElementContainer::const_iterator iEnd (maElementContainer.end());
    1034           0 :     for (iPart=maElementContainer.begin(); iPart!=iEnd; ++iPart)
    1035             :     {
    1036           0 :         ElementContainerPart::iterator iElement;
    1037           0 :         ElementContainerPart::const_iterator iPartEnd ((*iPart)->end());
    1038           0 :         for (iElement=(*iPart)->begin(); iElement!=iPartEnd; ++iElement)
    1039             :         {
    1040           0 :             if (iElement->get() == NULL)
    1041           0 :                 continue;
    1042             : 
    1043           0 :             awt::Rectangle aBox ((*iElement)->GetBoundingBox());
    1044             :             const bool bIsOver = bOverWindow
    1045           0 :                 && aBox.X <= rTemp.X
    1046           0 :                 && aBox.Width+aBox.X-1 >= rTemp.X
    1047           0 :                 && aBox.Y <= rTemp.Y
    1048           0 :                 && aBox.Height+aBox.Y-1 >= rTemp.Y;
    1049           0 :             (*iElement)->SetState(
    1050             :                 bIsOver,
    1051           0 :                 bIsOver && rTemp.Buttons!=0 && bMouseDown && rTemp.ClickCount>0);
    1052             :         }
    1053           0 :     }
    1054           0 : }
    1055             : 
    1056           0 : void PresenterToolBar::ThrowIfDisposed (void) const
    1057             :     throw (::com::sun::star::lang::DisposedException)
    1058             : {
    1059           0 :     if (rBHelper.bDisposed || rBHelper.bInDispose)
    1060             :     {
    1061             :         throw lang::DisposedException (
    1062             :             OUString( "PresenterToolBar has already been disposed"),
    1063           0 :             const_cast<uno::XWeak*>(static_cast<const uno::XWeak*>(this)));
    1064             :     }
    1065           0 : }
    1066             : 
    1067             : //===== PresenterToolBarView ==================================================
    1068             : 
    1069           0 : PresenterToolBarView::PresenterToolBarView (
    1070             :     const Reference<XComponentContext>& rxContext,
    1071             :     const Reference<XResourceId>& rxViewId,
    1072             :     const Reference<frame::XController>& rxController,
    1073             :     const ::rtl::Reference<PresenterController>& rpPresenterController)
    1074             :     : PresenterToolBarViewInterfaceBase(m_aMutex),
    1075             :       mxPane(),
    1076             :       mxViewId(rxViewId),
    1077             :       mxWindow(),
    1078             :       mxCanvas(),
    1079             :       mpPresenterController(rpPresenterController),
    1080             :       mxSlideShowController(rpPresenterController->GetSlideShowController()),
    1081           0 :       mpToolBar()
    1082             : {
    1083             :     try
    1084             :     {
    1085           0 :         Reference<XControllerManager> xCM (rxController, UNO_QUERY_THROW);
    1086           0 :         Reference<XConfigurationController> xCC(xCM->getConfigurationController(),UNO_QUERY_THROW);
    1087           0 :         mxPane = Reference<XPane>(xCC->getResource(rxViewId->getAnchor()), UNO_QUERY_THROW);
    1088             : 
    1089           0 :         mxWindow = mxPane->getWindow();
    1090           0 :         mxCanvas = mxPane->getCanvas();
    1091             : 
    1092           0 :         mpToolBar = new PresenterToolBar(
    1093             :             rxContext,
    1094             :             mxWindow,
    1095             :             mxCanvas,
    1096             :             rpPresenterController,
    1097           0 :             PresenterToolBar::Center);
    1098           0 :         mpToolBar->Initialize("PresenterScreenSettings/ToolBars/ToolBar");
    1099             : 
    1100           0 :         if (mxWindow.is())
    1101             :         {
    1102           0 :             mxWindow->addPaintListener(this);
    1103             : 
    1104           0 :             Reference<awt::XWindowPeer> xPeer (mxWindow, UNO_QUERY);
    1105           0 :             if (xPeer.is())
    1106           0 :                 xPeer->setBackground(util::Color(0xff000000));
    1107             : 
    1108           0 :             mxWindow->setVisible(sal_True);
    1109           0 :         }
    1110             :     }
    1111           0 :     catch (RuntimeException&)
    1112             :     {
    1113           0 :         mxViewId = NULL;
    1114           0 :         throw;
    1115             :     }
    1116           0 : }
    1117             : 
    1118           0 : PresenterToolBarView::~PresenterToolBarView (void)
    1119             : {
    1120           0 : }
    1121             : 
    1122           0 : void SAL_CALL PresenterToolBarView::disposing (void)
    1123             : {
    1124           0 :     Reference<lang::XComponent> xComponent (static_cast<XWeak*>(mpToolBar.get()), UNO_QUERY);
    1125           0 :     mpToolBar = NULL;
    1126           0 :     if (xComponent.is())
    1127           0 :         xComponent->dispose();
    1128             : 
    1129           0 :     if (mxWindow.is())
    1130             :     {
    1131           0 :         mxWindow->removePaintListener(this);
    1132           0 :         mxWindow = NULL;
    1133             :     }
    1134           0 :     mxCanvas = NULL;
    1135           0 :     mxViewId = NULL;
    1136           0 :     mxPane = NULL;
    1137           0 :     mpPresenterController = NULL;
    1138           0 :     mxSlideShowController = NULL;
    1139             : 
    1140           0 : }
    1141             : 
    1142           0 : ::rtl::Reference<PresenterToolBar> PresenterToolBarView::GetPresenterToolBar (void) const
    1143             : {
    1144           0 :     return mpToolBar;
    1145             : }
    1146             : 
    1147             : //----- XPaintListener --------------------------------------------------------
    1148             : 
    1149           0 : void SAL_CALL PresenterToolBarView::windowPaint (const css::awt::PaintEvent& rEvent)
    1150             :     throw (RuntimeException, std::exception)
    1151             : {
    1152           0 :     awt::Rectangle aWindowBox (mxWindow->getPosSize());
    1153             :     mpPresenterController->GetCanvasHelper()->Paint(
    1154           0 :         mpPresenterController->GetViewBackground(mxViewId->getResourceURL()),
    1155             :         mxCanvas,
    1156             :         rEvent.UpdateRect,
    1157             :         awt::Rectangle(0,0,aWindowBox.Width, aWindowBox.Height),
    1158           0 :         awt::Rectangle());
    1159           0 : }
    1160             : 
    1161             : //-----  lang::XEventListener -------------------------------------------------
    1162             : 
    1163           0 : void SAL_CALL PresenterToolBarView::disposing (const lang::EventObject& rEventObject)
    1164             :     throw (RuntimeException, std::exception)
    1165             : {
    1166           0 :     if (rEventObject.Source == mxWindow)
    1167           0 :         mxWindow = NULL;
    1168           0 : }
    1169             : 
    1170             : //----- XResourceId -----------------------------------------------------------
    1171             : 
    1172           0 : Reference<XResourceId> SAL_CALL PresenterToolBarView::getResourceId (void)
    1173             :     throw (RuntimeException, std::exception)
    1174             : {
    1175           0 :     return mxViewId;
    1176             : }
    1177             : 
    1178           0 : sal_Bool SAL_CALL PresenterToolBarView::isAnchorOnly (void)
    1179             :     throw (RuntimeException, std::exception)
    1180             : {
    1181           0 :     return false;
    1182             : }
    1183             : 
    1184             : //----- XDrawView -------------------------------------------------------------
    1185             : 
    1186           0 : void SAL_CALL PresenterToolBarView::setCurrentPage (const Reference<drawing::XDrawPage>& rxSlide)
    1187             :     throw (RuntimeException, std::exception)
    1188             : {
    1189           0 :     Reference<drawing::XDrawView> xToolBar (static_cast<XWeak*>(mpToolBar.get()), UNO_QUERY);
    1190           0 :     if (xToolBar.is())
    1191           0 :         xToolBar->setCurrentPage(rxSlide);
    1192           0 : }
    1193             : 
    1194           0 : Reference<drawing::XDrawPage> SAL_CALL PresenterToolBarView::getCurrentPage (void)
    1195             :     throw (RuntimeException, std::exception)
    1196             : {
    1197           0 :     return NULL;
    1198             : }
    1199             : 
    1200             : //===== PresenterToolBar::Element =============================================
    1201             : 
    1202             : namespace {
    1203             : 
    1204           0 : Element::Element (
    1205             :     const ::rtl::Reference<PresenterToolBar>& rpToolBar)
    1206             :     : ElementInterfaceBase(m_aMutex),
    1207             :       mpToolBar(rpToolBar),
    1208             :       maLocation(),
    1209             :       maSize(),
    1210             :       mpNormal(),
    1211             :       mpMouseOver(),
    1212             :       mpSelected(),
    1213             :       mpDisabled(),
    1214             :       mpMode(),
    1215             :       mbIsOver(false),
    1216             :       mbIsPressed(false),
    1217             :       mbIsSelected(false),
    1218           0 :       mbIsEnabled(true)
    1219             : {
    1220           0 :     if (mpToolBar.get() != NULL)
    1221             :     {
    1222             :         OSL_ASSERT(mpToolBar->GetPresenterController().is());
    1223             :         OSL_ASSERT(mpToolBar->GetPresenterController()->GetWindowManager().is());
    1224             :     }
    1225           0 : }
    1226             : 
    1227           0 : Element::~Element (void)
    1228             : {
    1229           0 : }
    1230             : 
    1231           0 : void Element::SetModes (
    1232             :     const SharedElementMode& rpNormalMode,
    1233             :     const SharedElementMode& rpMouseOverMode,
    1234             :     const SharedElementMode& rpSelectedMode,
    1235             :     const SharedElementMode& rpDisabledMode)
    1236             : {
    1237           0 :     mpNormal = rpNormalMode;
    1238           0 :     mpMouseOver = rpMouseOverMode;
    1239           0 :     mpSelected = rpSelectedMode;
    1240           0 :     mpDisabled = rpDisabledMode;
    1241           0 :     mpMode = rpNormalMode;
    1242           0 : }
    1243             : 
    1244           0 : void Element::disposing (void)
    1245             : {
    1246           0 : }
    1247             : 
    1248           0 : awt::Size Element::GetBoundingSize (
    1249             :     const Reference<rendering::XCanvas>& rxCanvas)
    1250             : {
    1251           0 :     maSize = CreateBoundingSize(rxCanvas);
    1252           0 :     return maSize;
    1253             : }
    1254             : 
    1255           0 : awt::Rectangle Element::GetBoundingBox (void) const
    1256             : {
    1257           0 :     return awt::Rectangle(maLocation.X,maLocation.Y, maSize.Width, maSize.Height);
    1258             : }
    1259             : 
    1260           0 : void Element::CurrentSlideHasChanged (void)
    1261             : {
    1262           0 :     UpdateState();
    1263           0 : }
    1264             : 
    1265           0 : void Element::SetLocation (const awt::Point& rLocation)
    1266             : {
    1267           0 :     maLocation = rLocation;
    1268           0 : }
    1269             : 
    1270           0 : void Element::SetSize (const geometry::RealSize2D& rSize)
    1271             : {
    1272           0 :     maSize = awt::Size(sal_Int32(0.5+rSize.Width), sal_Int32(0.5+rSize.Height));
    1273           0 : }
    1274             : 
    1275           0 : bool Element::SetState (
    1276             :     const bool bIsOver,
    1277             :     const bool bIsPressed)
    1278             : {
    1279           0 :     bool bModified (mbIsOver != bIsOver || mbIsPressed != bIsPressed);
    1280           0 :     bool bClicked (mbIsPressed && bIsOver && ! bIsPressed);
    1281             : 
    1282           0 :     mbIsOver = bIsOver;
    1283           0 :     mbIsPressed = bIsPressed;
    1284             : 
    1285             :     // When the element is disabled then ignore mouse over or selection.
    1286             :     // When the element is selected then ignore mouse over.
    1287           0 :     if ( ! mbIsEnabled)
    1288           0 :         mpMode = mpDisabled;
    1289           0 :     else if (mbIsSelected)
    1290           0 :         mpMode = mpSelected;
    1291           0 :     else if (mbIsOver)
    1292           0 :         mpMode = mpMouseOver;
    1293             :     else
    1294           0 :         mpMode = mpNormal;
    1295             : 
    1296           0 :     if (bClicked && mbIsEnabled)
    1297             :     {
    1298           0 :         if (mpMode.get() != NULL)
    1299             :         {
    1300             :             do
    1301             :             {
    1302           0 :                 if (mpMode->msAction.isEmpty())
    1303           0 :                     break;
    1304             : 
    1305           0 :                 if (mpToolBar.get() == NULL)
    1306           0 :                     break;
    1307             : 
    1308           0 :                 if (mpToolBar->GetPresenterController().get() == NULL)
    1309           0 :                     break;
    1310             : 
    1311           0 :                 mpToolBar->GetPresenterController()->DispatchUnoCommand(mpMode->msAction);
    1312           0 :                 mpToolBar->RequestLayout();
    1313             :             }
    1314             :             while (false);
    1315             :         }
    1316             : 
    1317             :     }
    1318           0 :     else if (bModified)
    1319             :     {
    1320           0 :         Invalidate();
    1321             :     }
    1322             : 
    1323           0 :     return bModified;
    1324             : }
    1325             : 
    1326           0 : void Element::Invalidate (const bool bSynchronous)
    1327             : {
    1328             :     OSL_ASSERT(mpToolBar.is());
    1329           0 :     mpToolBar->InvalidateArea(GetBoundingBox(), bSynchronous);
    1330           0 : }
    1331             : 
    1332           0 : bool Element::IsOutside (const awt::Rectangle& rBox)
    1333             : {
    1334           0 :     if (rBox.X >= maLocation.X+maSize.Width)
    1335           0 :         return true;
    1336           0 :     else if (rBox.Y >= maLocation.Y+maSize.Height)
    1337           0 :         return true;
    1338           0 :     else if (maLocation.X >= rBox.X+rBox.Width)
    1339           0 :         return true;
    1340           0 :     else if (maLocation.Y >= rBox.Y+rBox.Height)
    1341           0 :         return true;
    1342             :     else
    1343           0 :         return false;
    1344             : }
    1345             : 
    1346             : 
    1347           0 : bool Element::IsFilling (void) const
    1348             : {
    1349           0 :     return false;
    1350             : }
    1351             : 
    1352           0 : void Element::UpdateState (void)
    1353             : {
    1354             :     OSL_ASSERT(mpToolBar.get() != NULL);
    1355             :     OSL_ASSERT(mpToolBar->GetPresenterController().get() != NULL);
    1356             : 
    1357           0 :     if (mpMode.get() == NULL)
    1358           0 :         return;
    1359             : 
    1360           0 :     util::URL aURL (mpToolBar->GetPresenterController()->CreateURLFromString(mpMode->msAction));
    1361           0 :     Reference<frame::XDispatch> xDispatch (mpToolBar->GetPresenterController()->GetDispatch(aURL));
    1362           0 :     if (xDispatch.is())
    1363             :     {
    1364           0 :         xDispatch->addStatusListener(this, aURL);
    1365           0 :         xDispatch->removeStatusListener(this, aURL);
    1366           0 :     }
    1367             : }
    1368             : 
    1369             : //----- lang::XEventListener --------------------------------------------------
    1370             : 
    1371           0 : void SAL_CALL Element::disposing (const css::lang::EventObject& rEvent)
    1372             :     throw(css::uno::RuntimeException, std::exception)
    1373             : {
    1374             :     (void)rEvent;
    1375           0 : }
    1376             : 
    1377             : //----- document::XEventListener ----------------------------------------------
    1378             : 
    1379           0 : void SAL_CALL Element::notifyEvent (const css::document::EventObject& rEvent)
    1380             :     throw(css::uno::RuntimeException, std::exception)
    1381             : {
    1382             :     (void)rEvent;
    1383           0 :     UpdateState();
    1384           0 : }
    1385             : 
    1386             : //----- frame::XStatusListener ------------------------------------------------
    1387             : 
    1388           0 : void SAL_CALL Element::statusChanged (const css::frame::FeatureStateEvent& rEvent)
    1389             :     throw(css::uno::RuntimeException, std::exception)
    1390             : {
    1391           0 :     bool bIsSelected (mbIsSelected);
    1392           0 :     bool bIsEnabled (rEvent.IsEnabled);
    1393           0 :     rEvent.State >>= bIsSelected;
    1394             : 
    1395           0 :     if (bIsSelected != mbIsSelected || bIsEnabled != mbIsEnabled)
    1396             :     {
    1397           0 :         mbIsEnabled = bIsEnabled;
    1398           0 :         mbIsSelected = bIsSelected;
    1399           0 :         SetState(mbIsOver, mbIsPressed);
    1400           0 :         mpToolBar->RequestLayout();
    1401             :     }
    1402           0 : }
    1403             : 
    1404             : } // end of anonymous namespace
    1405             : 
    1406             : //===== ElementMode ===========================================================
    1407             : 
    1408             : namespace {
    1409             : 
    1410           0 : ElementMode::ElementMode (void)
    1411             :     : mpIcon(),
    1412             :       msAction(),
    1413           0 :       maText()
    1414             : {
    1415           0 : }
    1416             : 
    1417           0 : void ElementMode::ReadElementMode (
    1418             :     const Reference<beans::XPropertySet>& rxElementProperties,
    1419             :     const OUString& rsModeName,
    1420             :     ::boost::shared_ptr<ElementMode>& rpDefaultMode,
    1421             :     ::sdext::presenter::PresenterToolBar::Context& rContext)
    1422             : {
    1423             :     try
    1424             :     {
    1425             :     Reference<container::XHierarchicalNameAccess> xNode (
    1426             :         PresenterConfigurationAccess::GetProperty(rxElementProperties, rsModeName),
    1427           0 :         UNO_QUERY);
    1428             :     Reference<beans::XPropertySet> xProperties (
    1429           0 :         PresenterConfigurationAccess::GetNodeProperties(xNode, OUString()));
    1430           0 :     if ( ! xProperties.is() && rpDefaultMode.get()!=NULL)
    1431             :     {
    1432             :         // The mode is not specified.  Use the given, possibly empty,
    1433             :         // default mode instead.
    1434           0 :         mpIcon = rpDefaultMode->mpIcon;
    1435           0 :         msAction = rpDefaultMode->msAction;
    1436           0 :         maText = rpDefaultMode->maText;
    1437             :     }
    1438             : 
    1439             :     // Read action.
    1440           0 :     if ( ! (PresenterConfigurationAccess::GetProperty(xProperties, "Action") >>= msAction))
    1441           0 :         if (rpDefaultMode.get()!=NULL)
    1442           0 :             msAction = rpDefaultMode->msAction;
    1443             : 
    1444             :     // Read text and font
    1445           0 :     OUString sText (rpDefaultMode.get()!=NULL ? rpDefaultMode->maText.GetText() : OUString());
    1446           0 :     PresenterConfigurationAccess::GetProperty(xProperties, "Text") >>= sText;
    1447             :     Reference<container::XHierarchicalNameAccess> xFontNode (
    1448           0 :         PresenterConfigurationAccess::GetProperty(xProperties, "Font"), UNO_QUERY);
    1449             :     PresenterTheme::SharedFontDescriptor pFont (PresenterTheme::ReadFont(
    1450             :         xFontNode,
    1451             :         "",
    1452           0 :         rpDefaultMode.get()!=NULL
    1453           0 :             ? rpDefaultMode->maText.GetFont()
    1454           0 :             : PresenterTheme::SharedFontDescriptor()));
    1455           0 :     maText = Text(sText,pFont);
    1456             : 
    1457             :     // Read bitmaps to display as icons.
    1458             :     Reference<container::XHierarchicalNameAccess> xIconNode (
    1459           0 :         PresenterConfigurationAccess::GetProperty(xProperties, "Icon"), UNO_QUERY);
    1460           0 :     mpIcon = PresenterBitmapContainer::LoadBitmap(
    1461             :         xIconNode,
    1462             :         "",
    1463             :         rContext.mxPresenterHelper,
    1464             :         rContext.mxCanvas,
    1465           0 :         rpDefaultMode.get()!=NULL ? rpDefaultMode->mpIcon : SharedBitmapDescriptor());
    1466             :     }
    1467           0 :     catch(Exception&)
    1468             :     {
    1469             :         OSL_ASSERT(false);
    1470             :     }
    1471           0 : }
    1472             : 
    1473             : } // end of anonymous namespace
    1474             : 
    1475             : //===== Button ================================================================
    1476             : 
    1477             : namespace {
    1478             : 
    1479           0 : ::rtl::Reference<Element> Button::Create (
    1480             :     const ::rtl::Reference<PresenterToolBar>& rpToolBar)
    1481             : {
    1482           0 :     ::rtl::Reference<Button> pElement (new Button(rpToolBar));
    1483           0 :     pElement->Initialize();
    1484           0 :     return ::rtl::Reference<Element>(pElement.get());
    1485             : }
    1486             : 
    1487           0 : Button::Button (
    1488             :     const ::rtl::Reference<PresenterToolBar>& rpToolBar)
    1489             :     : Element(rpToolBar),
    1490           0 :       mbIsListenerRegistered(false)
    1491             : {
    1492             :     OSL_ASSERT(mpToolBar.get() != NULL);
    1493             :     OSL_ASSERT(mpToolBar->GetPresenterController().is());
    1494             :     OSL_ASSERT(mpToolBar->GetPresenterController()->GetWindowManager().is());
    1495           0 : }
    1496             : 
    1497           0 : Button::~Button (void)
    1498             : {
    1499           0 : }
    1500             : 
    1501           0 : void Button::Initialize (void)
    1502             : {
    1503           0 :     mpToolBar->GetPresenterController()->GetWindowManager()->AddLayoutListener(this);
    1504           0 :     mbIsListenerRegistered = true;
    1505           0 : }
    1506             : 
    1507           0 : void Button::disposing (void)
    1508             : {
    1509             :     OSL_ASSERT(mpToolBar.get() != NULL);
    1510           0 :     if (mpToolBar.get() != NULL
    1511           0 :         && mbIsListenerRegistered)
    1512             :     {
    1513             :         OSL_ASSERT(mpToolBar->GetPresenterController().is());
    1514             :         OSL_ASSERT(mpToolBar->GetPresenterController()->GetWindowManager().is());
    1515             : 
    1516           0 :         mbIsListenerRegistered = false;
    1517           0 :         mpToolBar->GetPresenterController()->GetWindowManager()->RemoveLayoutListener(this);
    1518             :     }
    1519           0 :     Element::disposing();
    1520           0 : }
    1521             : 
    1522           0 : void Button::Paint (
    1523             :     const Reference<rendering::XCanvas>& rxCanvas,
    1524             :     const rendering::ViewState& rViewState)
    1525             : {
    1526             :     OSL_ASSERT(rxCanvas.is());
    1527             : 
    1528           0 :     if (mpMode.get() == NULL)
    1529           0 :         return;
    1530             : 
    1531           0 :     if (mpMode->mpIcon.get() == NULL)
    1532           0 :         return;
    1533             : 
    1534           0 :     geometry::RealRectangle2D aTextBBox (mpMode->maText.GetBoundingBox(rxCanvas));
    1535           0 :     sal_Int32 nTextHeight (sal::static_int_cast<sal_Int32>(0.5 + aTextBBox.Y2 - aTextBBox.Y1));
    1536             : 
    1537           0 :     PaintIcon(rxCanvas, nTextHeight, rViewState);
    1538           0 :     awt::Point aOffset(0,0);
    1539           0 :     if ( ! IsEnabled())
    1540           0 :         if (mpMode->mpIcon.get() != NULL)
    1541             :         {
    1542           0 :             Reference<rendering::XBitmap> xBitmap (mpMode->mpIcon->GetNormalBitmap());
    1543           0 :             if (xBitmap.is())
    1544           0 :                 aOffset.Y = xBitmap->getSize().Height;
    1545             :         }
    1546           0 :     mpMode->maText.Paint(rxCanvas, rViewState, GetBoundingBox(), aOffset);
    1547             : }
    1548             : 
    1549           0 : awt::Size Button::CreateBoundingSize (
    1550             :     const Reference<rendering::XCanvas>& rxCanvas)
    1551             : {
    1552           0 :     if (mpMode.get() == NULL)
    1553           0 :         return awt::Size();
    1554             : 
    1555           0 :     geometry::RealRectangle2D aTextBBox (mpMode->maText.GetBoundingBox(rxCanvas));
    1556           0 :     const sal_Int32 nGap (5);
    1557           0 :     sal_Int32 nTextHeight (sal::static_int_cast<sal_Int32>(0.5 + aTextBBox.Y2 - aTextBBox.Y1));
    1558           0 :     sal_Int32 nTextWidth (sal::static_int_cast<sal_Int32>(0.5 + aTextBBox.X2 - aTextBBox.X1));
    1559           0 :     Reference<rendering::XBitmap> xBitmap;
    1560           0 :     if (mpMode->mpIcon.get() != NULL)
    1561           0 :         xBitmap = mpMode->mpIcon->GetNormalBitmap();
    1562           0 :     if (xBitmap.is())
    1563             :     {
    1564           0 :         geometry::IntegerSize2D aSize (xBitmap->getSize());
    1565             :         return awt::Size(
    1566           0 :             ::std::max(aSize.Width, sal_Int32(0.5 + aTextBBox.X2 - aTextBBox.X1)),
    1567           0 :             aSize.Height+ nGap + nTextHeight);
    1568             :     }
    1569             :     else
    1570           0 :         return awt::Size(nTextWidth,nTextHeight);
    1571             : }
    1572             : 
    1573           0 : void Button::PaintIcon (
    1574             :     const Reference<rendering::XCanvas>& rxCanvas,
    1575             :     const sal_Int32 nTextHeight,
    1576             :     const rendering::ViewState& rViewState)
    1577             : {
    1578           0 :     if (mpMode.get() == NULL)
    1579           0 :         return;
    1580             : 
    1581           0 :     Reference<rendering::XBitmap> xBitmap (mpMode->mpIcon->GetBitmap(GetMode()));
    1582           0 :     if (xBitmap.is())
    1583             :     {
    1584             :         /// check whether RTL interface or not
    1585           0 :         if(!Application::GetSettings().GetLayoutRTL()){
    1586             :             const sal_Int32 nX (maLocation.X
    1587           0 :                 + (maSize.Width-xBitmap->getSize().Width) / 2);
    1588             :             const sal_Int32 nY (maLocation.Y
    1589           0 :                 + (maSize.Height - nTextHeight - xBitmap->getSize().Height) / 2);
    1590             :             const rendering::RenderState aRenderState(
    1591             :                 geometry::AffineMatrix2D(1,0,nX, 0,1,nY),
    1592             :                 NULL,
    1593             :                 Sequence<double>(4),
    1594           0 :                 rendering::CompositeOperation::OVER);
    1595           0 :             rxCanvas->drawBitmap(xBitmap, rViewState, aRenderState);
    1596             :         }
    1597             :         else {
    1598             :             const sal_Int32 nX (maLocation.X
    1599           0 :                 + (maSize.Width+xBitmap->getSize().Width) / 2);
    1600             :             const sal_Int32 nY (maLocation.Y
    1601           0 :                 + (maSize.Height - nTextHeight - xBitmap->getSize().Height) / 2);
    1602             :             const rendering::RenderState aRenderState(
    1603             :                 geometry::AffineMatrix2D(-1,0,nX, 0,1,nY),
    1604             :                 NULL,
    1605             :                 Sequence<double>(4),
    1606           0 :                 rendering::CompositeOperation::OVER);
    1607           0 :             rxCanvas->drawBitmap(xBitmap, rViewState, aRenderState);
    1608             :         }
    1609           0 :     }
    1610             : }
    1611             : 
    1612           0 : PresenterBitmapDescriptor::Mode Button::GetMode (void) const
    1613             : {
    1614           0 :     if ( ! IsEnabled())
    1615           0 :         return PresenterBitmapDescriptor::Disabled;
    1616           0 :     else if (mbIsPressed)
    1617           0 :         return PresenterBitmapDescriptor::ButtonDown;
    1618           0 :     else if (mbIsOver)
    1619           0 :         return PresenterBitmapDescriptor::MouseOver;
    1620             :     else
    1621           0 :         return PresenterBitmapDescriptor::Normal;
    1622             : }
    1623             : 
    1624             : //----- lang::XEventListener --------------------------------------------------
    1625             : 
    1626           0 : void SAL_CALL Button::disposing (const css::lang::EventObject& rEvent)
    1627             :     throw(css::uno::RuntimeException, std::exception)
    1628             : {
    1629             :     (void)rEvent;
    1630           0 :     mbIsListenerRegistered = false;
    1631           0 :     Element::disposing(rEvent);
    1632           0 : }
    1633             : 
    1634             : } // end of anonymous namespace
    1635             : 
    1636             : //===== PresenterToolBar::Label ===============================================
    1637             : 
    1638             : namespace {
    1639             : 
    1640           0 : Label::Label (const ::rtl::Reference<PresenterToolBar>& rpToolBar)
    1641           0 :     : Element(rpToolBar)
    1642             : {
    1643           0 : }
    1644             : 
    1645           0 : awt::Size Label::CreateBoundingSize (
    1646             :     const Reference<rendering::XCanvas>& rxCanvas)
    1647             : {
    1648           0 :     if (mpMode.get() == NULL)
    1649           0 :         return awt::Size(0,0);
    1650             : 
    1651           0 :     geometry::RealRectangle2D aTextBBox (mpMode->maText.GetBoundingBox(rxCanvas));
    1652             :     return awt::Size(
    1653           0 :         sal::static_int_cast<sal_Int32>(0.5 + aTextBBox.X2 - aTextBBox.X1),
    1654           0 :         sal::static_int_cast<sal_Int32>(0.5 + aTextBBox.Y2 - aTextBBox.Y1));
    1655             : }
    1656             : 
    1657           0 : void Label::SetText (const OUString& rsText)
    1658             : {
    1659             :     OSL_ASSERT(mpToolBar.get() != NULL);
    1660           0 :     if (mpMode.get() == NULL)
    1661           0 :         return;
    1662             : 
    1663           0 :     const bool bRequestLayout (mpMode->maText.GetText().getLength() != rsText.getLength());
    1664             : 
    1665           0 :     mpMode->maText.SetText(rsText);
    1666             :     // Just use the character count for determing whether a layout is
    1667             :     // necessary.  This is an optimization to avoid layouts every time a new
    1668             :     // time value is set on some labels.
    1669           0 :     if (bRequestLayout)
    1670           0 :         mpToolBar->RequestLayout();
    1671             :     else
    1672           0 :         Invalidate(false);
    1673             : }
    1674             : 
    1675           0 : void Label::Paint (
    1676             :     const Reference<rendering::XCanvas>& rxCanvas,
    1677             :     const rendering::ViewState& rViewState)
    1678             : {
    1679             :     OSL_ASSERT(rxCanvas.is());
    1680           0 :     if (mpMode.get() == NULL)
    1681           0 :         return;
    1682             : 
    1683           0 :     mpMode->maText.Paint(rxCanvas, rViewState, GetBoundingBox(), awt::Point(0,0));
    1684             : }
    1685             : 
    1686           0 : bool Label::SetState (const bool bIsOver, const bool bIsPressed)
    1687             : {
    1688             :     // For labels there is no mouse over effect.
    1689             :     (void)bIsOver;
    1690             :     (void)bIsPressed;
    1691           0 :     return Element::SetState(false, false);
    1692             : }
    1693             : 
    1694             : } // end of anonymous namespace
    1695             : 
    1696             : //===== Text ==================================================================
    1697             : 
    1698             : namespace {
    1699             : 
    1700           0 : Text::Text (void)
    1701             :     : msText(),
    1702           0 :       mpFont()
    1703             : {
    1704           0 : }
    1705             : 
    1706           0 : Text::Text (
    1707             :     const OUString& rsText,
    1708             :     const PresenterTheme::SharedFontDescriptor& rpFont)
    1709             :     : msText(rsText),
    1710           0 :       mpFont(rpFont)
    1711             : {
    1712           0 : }
    1713             : 
    1714           0 : void Text::SetText (const OUString& rsText)
    1715             : {
    1716           0 :     msText = rsText;
    1717           0 : }
    1718             : 
    1719           0 : OUString Text::GetText (void) const
    1720             : {
    1721           0 :     return msText;
    1722             : }
    1723             : 
    1724           0 : PresenterTheme::SharedFontDescriptor Text::GetFont (void) const
    1725             : {
    1726           0 :     return mpFont;
    1727             : }
    1728             : 
    1729           0 : void Text::Paint (
    1730             :     const Reference<rendering::XCanvas>& rxCanvas,
    1731             :     const rendering::ViewState& rViewState,
    1732             :     const awt::Rectangle& rBoundingBox,
    1733             :     const awt::Point& rOffset)
    1734             : {
    1735             :     (void)rOffset;
    1736             :     OSL_ASSERT(rxCanvas.is());
    1737             : 
    1738           0 :     if (msText.isEmpty())
    1739           0 :         return;
    1740           0 :     if (mpFont.get() == NULL)
    1741           0 :         return;
    1742             : 
    1743           0 :     if ( ! mpFont->mxFont.is())
    1744           0 :         mpFont->PrepareFont(rxCanvas);
    1745           0 :     if ( ! mpFont->mxFont.is())
    1746           0 :         return;
    1747             : 
    1748           0 :     rendering::StringContext aContext (msText, 0, msText.getLength());
    1749             : 
    1750             :     Reference<rendering::XTextLayout> xLayout (
    1751           0 :         mpFont->mxFont->createTextLayout(
    1752             :             aContext,
    1753             :             rendering::TextDirection::WEAK_LEFT_TO_RIGHT,
    1754           0 :             0));
    1755           0 :     geometry::RealRectangle2D aBox (xLayout->queryTextBounds());
    1756           0 :     const double nTextWidth = aBox.X2 - aBox.X1;
    1757           0 :     const double nY = rBoundingBox.Y + rBoundingBox.Height - aBox.Y2;
    1758           0 :     const double nX = rBoundingBox.X + (rBoundingBox.Width - nTextWidth)/2;
    1759             : 
    1760             :     rendering::RenderState aRenderState(
    1761             :         geometry::AffineMatrix2D(1,0,nX, 0,1,nY),
    1762             :         NULL,
    1763             :         Sequence<double>(4),
    1764           0 :         rendering::CompositeOperation::SOURCE);
    1765           0 :     PresenterCanvasHelper::SetDeviceColor(aRenderState, mpFont->mnColor);
    1766           0 :     rxCanvas->drawTextLayout(
    1767             :         xLayout,
    1768             :         rViewState,
    1769           0 :         aRenderState);
    1770             : }
    1771             : 
    1772           0 : geometry::RealRectangle2D Text::GetBoundingBox (const Reference<rendering::XCanvas>& rxCanvas)
    1773             : {
    1774           0 :     if (mpFont.get() != NULL && !msText.isEmpty())
    1775             :     {
    1776           0 :         if ( ! mpFont->mxFont.is())
    1777           0 :             mpFont->PrepareFont(rxCanvas);
    1778           0 :         if (mpFont->mxFont.is())
    1779             :         {
    1780           0 :             rendering::StringContext aContext (msText, 0, msText.getLength());
    1781             :                 Reference<rendering::XTextLayout> xLayout (
    1782           0 :                 mpFont->mxFont->createTextLayout(
    1783             :                     aContext,
    1784             :                     rendering::TextDirection::WEAK_LEFT_TO_RIGHT,
    1785           0 :                     0));
    1786           0 :             return xLayout->queryTextBounds();
    1787             :         }
    1788             :     }
    1789           0 :     return geometry::RealRectangle2D(0,0,0,0);
    1790             : }
    1791             : 
    1792             : //===== TimeFormatter =========================================================
    1793             : 
    1794           0 : TimeFormatter::TimeFormatter (void)
    1795             :     : mbIs24HourFormat(true),
    1796             :       mbIsAmPmFormat(false),
    1797           0 :       mbIsShowSeconds(true)
    1798             : {
    1799           0 : }
    1800             : 
    1801           0 : OUString TimeFormatter::FormatTime (const oslDateTime& rTime)
    1802             : {
    1803           0 :     OUStringBuffer sText;
    1804             : 
    1805           0 :     const sal_Int32 nHours (sal::static_int_cast<sal_Int32>(rTime.Hours));
    1806           0 :     const sal_Int32 nMinutes (sal::static_int_cast<sal_Int32>(rTime.Minutes));
    1807           0 :     const sal_Int32 nSeconds(sal::static_int_cast<sal_Int32>(rTime.Seconds));
    1808             :     // Hours
    1809           0 :     if (mbIs24HourFormat)
    1810           0 :         sText.append(OUString::number(nHours));
    1811             :     else
    1812             :         sText.append(OUString::number(
    1813           0 :             sal::static_int_cast<sal_Int32>(nHours>12 ? nHours-12 : nHours)));
    1814             : 
    1815           0 :     sText.append(":");
    1816             : 
    1817             :     // Minutes
    1818           0 :     const OUString sMinutes (OUString::number(nMinutes));
    1819           0 :     if (sMinutes.getLength() == 1)
    1820           0 :         sText.append("0");
    1821           0 :     sText.append(sMinutes);
    1822             : 
    1823             :     // Seconds
    1824           0 :     if (mbIsShowSeconds)
    1825             :     {
    1826           0 :         sText.append(":");
    1827           0 :         const OUString sSeconds (OUString::number(nSeconds));
    1828           0 :         if (sSeconds.getLength() == 1)
    1829           0 :             sText.append("0");
    1830           0 :         sText.append(sSeconds);
    1831             :     }
    1832           0 :     if (mbIsAmPmFormat)
    1833             :     {
    1834           0 :         if (rTime.Hours < 12)
    1835           0 :             sText.append("am");
    1836             :         else
    1837           0 :             sText.append("pm");
    1838             :     }
    1839           0 :     return sText.makeStringAndClear();
    1840             : }
    1841             : 
    1842             : //===== TimeLabel =============================================================
    1843             : 
    1844           0 : TimeLabel::TimeLabel (const ::rtl::Reference<PresenterToolBar>& rpToolBar)
    1845             :     : Label(rpToolBar),
    1846           0 :       mpListener()
    1847             : {
    1848           0 : }
    1849             : 
    1850           0 : void SAL_CALL TimeLabel::disposing (void)
    1851             : {
    1852           0 :     PresenterClockTimer::Instance(mpToolBar->GetComponentContext())->RemoveListener(mpListener);
    1853           0 :     mpListener.reset();
    1854           0 : }
    1855             : 
    1856           0 : void TimeLabel::ConnectToTimer (void)
    1857             : {
    1858           0 :     mpListener.reset(new Listener(this));
    1859           0 :     PresenterClockTimer::Instance(mpToolBar->GetComponentContext())->AddListener(mpListener);
    1860           0 : }
    1861             : 
    1862             : //===== CurrentTimeLabel ======================================================
    1863             : 
    1864           0 : ::rtl::Reference<Element> CurrentTimeLabel::Create (
    1865             :     const ::rtl::Reference<PresenterToolBar>& rpToolBar)
    1866             : {
    1867           0 :     ::rtl::Reference<TimeLabel> pElement(new CurrentTimeLabel(rpToolBar));
    1868           0 :     pElement->ConnectToTimer();
    1869           0 :     return ::rtl::Reference<Element>(pElement.get());
    1870             : }
    1871             : 
    1872           0 : CurrentTimeLabel::~CurrentTimeLabel (void)
    1873             : {
    1874           0 : }
    1875             : 
    1876           0 : CurrentTimeLabel::CurrentTimeLabel (
    1877             :     const ::rtl::Reference<PresenterToolBar>& rpToolBar)
    1878             :     : TimeLabel(rpToolBar),
    1879           0 :       maTimeFormatter()
    1880             : {
    1881           0 : }
    1882             : 
    1883           0 : void CurrentTimeLabel::TimeHasChanged (const oslDateTime& rCurrentTime)
    1884             : {
    1885           0 :     SetText(maTimeFormatter.FormatTime(rCurrentTime));
    1886           0 :     Invalidate(false);
    1887           0 : }
    1888             : 
    1889           0 : void CurrentTimeLabel::SetModes (
    1890             :     const SharedElementMode& rpNormalMode,
    1891             :     const SharedElementMode& rpMouseOverMode,
    1892             :     const SharedElementMode& rpSelectedMode,
    1893             :     const SharedElementMode& rpDisabledMode)
    1894             : {
    1895           0 :     TimeLabel::SetModes(rpNormalMode, rpMouseOverMode, rpSelectedMode, rpDisabledMode);
    1896           0 :     SetText(maTimeFormatter.FormatTime(PresenterClockTimer::GetCurrentTime()));
    1897           0 : }
    1898             : 
    1899             : //===== PresentationTimeLabel =================================================
    1900             : 
    1901           0 : ::rtl::Reference<Element> PresentationTimeLabel::Create (
    1902             :     const ::rtl::Reference<PresenterToolBar>& rpToolBar)
    1903             : {
    1904           0 :     ::rtl::Reference<TimeLabel> pElement(new PresentationTimeLabel(rpToolBar));
    1905           0 :     pElement->ConnectToTimer();
    1906           0 :     return ::rtl::Reference<Element>(pElement.get());
    1907             : }
    1908             : 
    1909           0 : PresentationTimeLabel::~PresentationTimeLabel (void)
    1910             : {
    1911           0 : }
    1912             : 
    1913           0 : PresentationTimeLabel::PresentationTimeLabel (
    1914             :     const ::rtl::Reference<PresenterToolBar>& rpToolBar)
    1915             :     : TimeLabel(rpToolBar),
    1916             :       maTimeFormatter(),
    1917           0 :       maStartTimeValue()
    1918             : {
    1919           0 :     maStartTimeValue.Seconds = 0;
    1920           0 :     maStartTimeValue.Nanosec = 0;
    1921           0 : }
    1922             : 
    1923           0 : void PresentationTimeLabel::TimeHasChanged (const oslDateTime& rCurrentTime)
    1924             : {
    1925             :     TimeValue aCurrentTimeValue;
    1926           0 :     if (osl_getTimeValueFromDateTime(&rCurrentTime, &aCurrentTimeValue))
    1927             :     {
    1928           0 :         if (maStartTimeValue.Seconds==0 && maStartTimeValue.Nanosec==0)
    1929             :         {
    1930             :             // This method is called for the first time.  Initialize the
    1931             :             // start time.  The start time is rounded to nearest second to
    1932             :             // keep the time updates synchronized with the current time label.
    1933           0 :             maStartTimeValue = aCurrentTimeValue;
    1934           0 :             if (maStartTimeValue.Nanosec >= 500000000)
    1935           0 :                 maStartTimeValue.Seconds += 1;
    1936           0 :             maStartTimeValue.Nanosec = 0;
    1937             :         }
    1938             : 
    1939             :         TimeValue aElapsedTimeValue;
    1940           0 :         aElapsedTimeValue.Seconds = aCurrentTimeValue.Seconds - maStartTimeValue.Seconds;
    1941           0 :         aElapsedTimeValue.Nanosec = aCurrentTimeValue.Nanosec - maStartTimeValue.Nanosec;
    1942             : 
    1943             :         oslDateTime aElapsedDateTime;
    1944           0 :         if (osl_getDateTimeFromTimeValue(&aElapsedTimeValue, &aElapsedDateTime))
    1945             :         {
    1946           0 :             SetText(maTimeFormatter.FormatTime(aElapsedDateTime));
    1947           0 :             Invalidate(false);
    1948             :         }
    1949             :     }
    1950           0 : }
    1951             : 
    1952           0 : void PresentationTimeLabel::SetModes (
    1953             :     const SharedElementMode& rpNormalMode,
    1954             :     const SharedElementMode& rpMouseOverMode,
    1955             :     const SharedElementMode& rpSelectedMode,
    1956             :     const SharedElementMode& rpDisabledMode)
    1957             : {
    1958           0 :     TimeLabel::SetModes(rpNormalMode, rpMouseOverMode, rpSelectedMode, rpDisabledMode);
    1959             : 
    1960             :     oslDateTime aStartDateTime;
    1961           0 :     if (osl_getDateTimeFromTimeValue(&maStartTimeValue, &aStartDateTime))
    1962             :     {
    1963           0 :         SetText(maTimeFormatter.FormatTime(aStartDateTime));
    1964             :     }
    1965           0 : }
    1966             : 
    1967             : //===== VerticalSeparator =====================================================
    1968             : 
    1969           0 : VerticalSeparator::VerticalSeparator (
    1970             :     const ::rtl::Reference<PresenterToolBar>& rpToolBar)
    1971           0 :     : Element(rpToolBar)
    1972             : {
    1973           0 : }
    1974             : 
    1975           0 : void VerticalSeparator::Paint (
    1976             :     const Reference<rendering::XCanvas>& rxCanvas,
    1977             :     const rendering::ViewState& rViewState)
    1978             : {
    1979             :     OSL_ASSERT(rxCanvas.is());
    1980             : 
    1981           0 :     awt::Rectangle aBBox (GetBoundingBox());
    1982             : 
    1983             :     rendering::RenderState aRenderState(
    1984             :         geometry::AffineMatrix2D(1,0,0, 0,1,0),
    1985             :         NULL,
    1986             :         Sequence<double>(4),
    1987           0 :         rendering::CompositeOperation::OVER);
    1988           0 :     if (mpMode.get() != NULL)
    1989             :     {
    1990           0 :         PresenterTheme::SharedFontDescriptor pFont (mpMode->maText.GetFont());
    1991           0 :         if (pFont.get() != NULL)
    1992           0 :             PresenterCanvasHelper::SetDeviceColor(aRenderState, pFont->mnColor);
    1993             :     }
    1994             : 
    1995           0 :     if (aBBox.Height >= gnMinimalSeparatorSize + 2*gnSeparatorInset)
    1996             :     {
    1997           0 :         aBBox.Height -= 2*gnSeparatorInset;
    1998           0 :         aBBox.Y += gnSeparatorInset;
    1999             :     }
    2000           0 :     rxCanvas->fillPolyPolygon(
    2001           0 :         PresenterGeometryHelper::CreatePolygon(aBBox, rxCanvas->getDevice()),
    2002             :         rViewState,
    2003           0 :         aRenderState);
    2004           0 : }
    2005             : 
    2006           0 : awt::Size VerticalSeparator::CreateBoundingSize (
    2007             :     const Reference<rendering::XCanvas>& rxCanvas)
    2008             : {
    2009             :     (void)rxCanvas;
    2010           0 :     return awt::Size(1,20);
    2011             : }
    2012             : 
    2013           0 : bool VerticalSeparator::IsFilling (void) const
    2014             : {
    2015           0 :     return true;
    2016             : }
    2017             : 
    2018             : //===== HorizontalSeparator ===================================================
    2019             : 
    2020           0 : HorizontalSeparator::HorizontalSeparator (
    2021             :     const ::rtl::Reference<PresenterToolBar>& rpToolBar)
    2022           0 :     : Element(rpToolBar)
    2023             : {
    2024           0 : }
    2025             : 
    2026           0 : void HorizontalSeparator::Paint (
    2027             :     const Reference<rendering::XCanvas>& rxCanvas,
    2028             :     const rendering::ViewState& rViewState)
    2029             : {
    2030             :     OSL_ASSERT(rxCanvas.is());
    2031             : 
    2032           0 :     awt::Rectangle aBBox (GetBoundingBox());
    2033             : 
    2034             :     rendering::RenderState aRenderState(
    2035             :         geometry::AffineMatrix2D(1,0,0, 0,1,0),
    2036             :         NULL,
    2037             :         Sequence<double>(4),
    2038           0 :         rendering::CompositeOperation::OVER);
    2039           0 :     if (mpMode.get() != NULL)
    2040             :     {
    2041           0 :         PresenterTheme::SharedFontDescriptor pFont (mpMode->maText.GetFont());
    2042           0 :         if (pFont.get() != NULL)
    2043           0 :             PresenterCanvasHelper::SetDeviceColor(aRenderState, pFont->mnColor);
    2044             :     }
    2045             : 
    2046           0 :     if (aBBox.Width >= gnMinimalSeparatorSize+2*gnSeparatorInset)
    2047             :     {
    2048           0 :         aBBox.Width -= 2*gnSeparatorInset;
    2049           0 :         aBBox.X += gnSeparatorInset;
    2050             :     }
    2051           0 :     rxCanvas->fillPolyPolygon(
    2052           0 :         PresenterGeometryHelper::CreatePolygon(aBBox, rxCanvas->getDevice()),
    2053             :         rViewState,
    2054           0 :         aRenderState);
    2055           0 : }
    2056             : 
    2057           0 : awt::Size HorizontalSeparator::CreateBoundingSize (
    2058             :     const Reference<rendering::XCanvas>& rxCanvas)
    2059             : {
    2060             :     (void)rxCanvas;
    2061           0 :     return awt::Size(20,1);
    2062             : }
    2063             : 
    2064           0 : bool HorizontalSeparator::IsFilling (void) const
    2065             : {
    2066           0 :     return true;
    2067             : }
    2068             : 
    2069             : } // end of anonymous namespace
    2070             : 
    2071          24 : } } // end of namespace ::sdext::presenter
    2072             : 
    2073             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10