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

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : 
      21             : #include "PresenterCanvas.hxx"
      22             : 
      23             : #include <basegfx/matrix/b2dhommatrix.hxx>
      24             : #include <basegfx/polygon/b2dpolygontools.hxx>
      25             : #include <basegfx/polygon/b2dpolypolygon.hxx>
      26             : #include <basegfx/polygon/b2dpolygonclipper.hxx>
      27             : #include <basegfx/range/b2drectangle.hxx>
      28             : #include <basegfx/tools/canvastools.hxx>
      29             : #include <canvas/canvastools.hxx>
      30             : #include <cppuhelper/basemutex.hxx>
      31             : #include <cppuhelper/compbase1.hxx>
      32             : #include <rtl/ref.hxx>
      33             : #include <toolkit/helper/vclunohelper.hxx>
      34             : #include <vcl/window.hxx>
      35             : #include <vcl/svapp.hxx>
      36             : 
      37             : using namespace ::com::sun::star;
      38             : using namespace ::com::sun::star::uno;
      39             : 
      40             : namespace sd { namespace presenter {
      41             : 
      42             : //===== Service ===============================================================
      43             : 
      44           0 : Reference<XInterface> SAL_CALL PresenterCanvas_createInstance (
      45             :     const Reference<XComponentContext>& rxContext)
      46             : {
      47             :     (void)rxContext;
      48           0 :     return Reference<XInterface>(static_cast<XWeak*>(new PresenterCanvas()));
      49             : }
      50             : 
      51             : 
      52             : 
      53             : 
      54           0 : OUString PresenterCanvas_getImplementationName (void) throw(RuntimeException)
      55             : {
      56           0 :     return OUString("com.sun.star.comp.Draw.PresenterCanvasFactory");
      57             : }
      58             : 
      59             : 
      60             : 
      61             : 
      62           0 : Sequence<OUString> SAL_CALL PresenterCanvas_getSupportedServiceNames (void)
      63             :     throw (RuntimeException)
      64             : {
      65           0 :     static const OUString sServiceName("com.sun.star.rendering.Canvas");
      66           0 :     return Sequence<OUString>(&sServiceName, 1);
      67             : }
      68             : 
      69             : 
      70             : 
      71             : 
      72             : //===== PresenterCustomSprite =================================================
      73             : 
      74             : /** Wrapper around a sprite that is displayed on a PresenterCanvas.
      75             : */
      76             : namespace {
      77             :     typedef ::cppu::WeakComponentImplHelper1 <
      78             :         css::rendering::XCustomSprite
      79             :     > PresenterCustomSpriteInterfaceBase;
      80             : }
      81             : class PresenterCustomSprite
      82             :     : private ::boost::noncopyable,
      83             :       protected ::cppu::BaseMutex,
      84             :       public PresenterCustomSpriteInterfaceBase
      85             : {
      86             : public:
      87             :     PresenterCustomSprite (
      88             :         const rtl::Reference<PresenterCanvas>& rpCanvas,
      89             :         const Reference<rendering::XCustomSprite>& rxSprite,
      90             :         const Reference<awt::XWindow>& rxBaseWindow,
      91             :         const css::geometry::RealSize2D& rSpriteSize);
      92             :     virtual ~PresenterCustomSprite (void);
      93             :     virtual void SAL_CALL disposing (void)
      94             :         throw (RuntimeException) SAL_OVERRIDE;
      95             : 
      96             :     // XSprite
      97             : 
      98             :     virtual void SAL_CALL setAlpha (double nAlpha)
      99             :         throw (lang::IllegalArgumentException,RuntimeException, std::exception) SAL_OVERRIDE;
     100             : 
     101             :     virtual void SAL_CALL move (const geometry::RealPoint2D& rNewPos,
     102             :         const rendering::ViewState& rViewState,
     103             :         const rendering::RenderState& rRenderState)
     104             :         throw (lang::IllegalArgumentException,RuntimeException, std::exception) SAL_OVERRIDE;
     105             : 
     106             :     virtual void SAL_CALL transform (const geometry::AffineMatrix2D& rTransformation)
     107             :         throw (lang::IllegalArgumentException,RuntimeException, std::exception) SAL_OVERRIDE;
     108             : 
     109             :     virtual void SAL_CALL clip (const Reference<rendering::XPolyPolygon2D>& rClip)
     110             :         throw (RuntimeException, std::exception) SAL_OVERRIDE;
     111             : 
     112             :     virtual void SAL_CALL setPriority (double nPriority)
     113             :         throw (RuntimeException, std::exception) SAL_OVERRIDE;
     114             : 
     115             :     virtual void SAL_CALL show (void)
     116             :         throw (RuntimeException, std::exception) SAL_OVERRIDE;
     117             : 
     118             :     virtual void SAL_CALL hide (void)
     119             :         throw (RuntimeException, std::exception) SAL_OVERRIDE;
     120             : 
     121             : 
     122             :     // XCustomSprite
     123             : 
     124             :     virtual Reference<rendering::XCanvas> SAL_CALL getContentCanvas (void)
     125             :         throw (RuntimeException, std::exception) SAL_OVERRIDE;
     126             : 
     127             : private:
     128             :     rtl::Reference<PresenterCanvas> mpCanvas;
     129             :     Reference<rendering::XCustomSprite> mxSprite;
     130             :     Reference<awt::XWindow> mxBaseWindow;
     131             :     geometry::RealPoint2D maPosition;
     132             :     geometry::RealSize2D maSpriteSize;
     133             : 
     134             :     void ThrowIfDisposed (void)
     135             :         throw (css::lang::DisposedException);
     136             : };
     137             : 
     138             : 
     139             : 
     140             : 
     141             : //===== PresenterCanvas =======================================================
     142             : 
     143             : 
     144           0 : PresenterCanvas::PresenterCanvas (void)
     145             :     : PresenterCanvasInterfaceBase(m_aMutex),
     146             :       mxUpdateCanvas(),
     147             :       mxSharedCanvas(),
     148             :       mxSharedWindow(),
     149             :       mxWindow(),
     150             :       maOffset(),
     151             :       mpUpdateRequester(),
     152             :       maClipRectangle(),
     153           0 :       mbOffsetUpdatePending(true)
     154             : {
     155           0 : }
     156             : 
     157             : 
     158             : 
     159             : 
     160           0 : PresenterCanvas::PresenterCanvas (
     161             :     const Reference<rendering::XSpriteCanvas>& rxUpdateCanvas,
     162             :     const Reference<awt::XWindow>& rxUpdateWindow,
     163             :     const Reference<rendering::XCanvas>& rxSharedCanvas,
     164             :     const Reference<awt::XWindow>& rxSharedWindow,
     165             :     const Reference<awt::XWindow>& rxWindow)
     166             :     : PresenterCanvasInterfaceBase(m_aMutex),
     167             :       mxUpdateCanvas(rxUpdateCanvas),
     168             :       mxUpdateWindow(rxUpdateWindow),
     169             :       mxSharedCanvas(rxSharedCanvas),
     170             :       mxSharedWindow(rxSharedWindow),
     171             :       mxWindow(rxWindow),
     172             :       maOffset(),
     173             :       mpUpdateRequester(),
     174             :       maClipRectangle(),
     175           0 :       mbOffsetUpdatePending(true)
     176             : {
     177           0 :     if (mxWindow.is())
     178           0 :         mxWindow->addWindowListener(this);
     179             : 
     180           0 :     if (mxUpdateCanvas.is())
     181           0 :         mpUpdateRequester = CanvasUpdateRequester::Instance(mxUpdateCanvas);
     182           0 : }
     183             : 
     184             : 
     185             : 
     186             : 
     187           0 : PresenterCanvas::~PresenterCanvas (void)
     188             : {
     189           0 : }
     190             : 
     191             : 
     192             : 
     193             : 
     194           0 : void SAL_CALL PresenterCanvas::disposing (void)
     195             :     throw (css::uno::RuntimeException)
     196             : {
     197           0 :     if (mxWindow.is())
     198           0 :         mxWindow->removeWindowListener(this);
     199           0 : }
     200             : 
     201             : 
     202             : 
     203             : 
     204             : //----- XInitialization -------------------------------------------------------
     205             : 
     206           0 : void SAL_CALL PresenterCanvas::initialize (
     207             :     const Sequence<Any>& rArguments)
     208             :     throw(Exception, RuntimeException, std::exception)
     209             : {
     210           0 :     if (rBHelper.bDisposed || rBHelper.bInDispose)
     211           0 :         ThrowIfDisposed();
     212             : 
     213           0 :     if (rArguments.getLength() == 5)
     214             :     {
     215             :         try
     216             :         {
     217             :             // First and second argument may be NULL.
     218           0 :             rArguments[0] >>= mxUpdateCanvas;
     219           0 :             rArguments[1] >>= mxUpdateWindow;
     220             : 
     221           0 :             if ( ! (rArguments[2] >>= mxSharedWindow))
     222             :             {
     223             :                 throw lang::IllegalArgumentException("PresenterCanvas: invalid shared window",
     224             :                     static_cast<XWeak*>(this),
     225           0 :                     1);
     226             :             }
     227             : 
     228           0 :             if ( ! (rArguments[3] >>= mxSharedCanvas))
     229             :             {
     230             :                 throw lang::IllegalArgumentException("PresenterCanvas: invalid shared canvas",
     231             :                     static_cast<XWeak*>(this),
     232           0 :                     2);
     233             :             }
     234             : 
     235           0 :             if ( ! (rArguments[4] >>= mxWindow))
     236             :             {
     237             :                 throw lang::IllegalArgumentException("PresenterCanvas: invalid window",
     238             :                     static_cast<XWeak*>(this),
     239           0 :                     3);
     240             :             }
     241             : 
     242           0 :             mpUpdateRequester = CanvasUpdateRequester::Instance(mxUpdateCanvas);
     243             : 
     244           0 :             mbOffsetUpdatePending = true;
     245           0 :             if (mxWindow.is())
     246           0 :                 mxWindow->addWindowListener(this);
     247             :         }
     248           0 :         catch (RuntimeException&)
     249             :         {
     250           0 :             mxSharedWindow = NULL;
     251           0 :             mxWindow = NULL;
     252           0 :             throw;
     253             :         }
     254             :     }
     255             :     else
     256             :     {
     257             :         throw RuntimeException("PresenterCanvas: invalid number of arguments",
     258           0 :                 static_cast<XWeak*>(this));
     259             :     }
     260           0 : }
     261             : 
     262             : 
     263             : 
     264             : 
     265             : //----- XCanvas ---------------------------------------------------------------
     266             : 
     267           0 : void SAL_CALL PresenterCanvas::clear (void)
     268             :     throw (css::uno::RuntimeException, std::exception)
     269             : {
     270           0 :     ThrowIfDisposed();
     271             :     // ToDo: Clear the area covered by the child window.  A simple forward
     272             :     // would clear the whole shared canvas.
     273           0 : }
     274             : 
     275             : 
     276             : 
     277             : 
     278           0 : void SAL_CALL PresenterCanvas::drawPoint (
     279             :     const css::geometry::RealPoint2D& aPoint,
     280             :     const css::rendering::ViewState& aViewState,
     281             :     const css::rendering::RenderState& aRenderState)
     282             :     throw (css::lang::IllegalArgumentException, css::uno::RuntimeException, std::exception)
     283             : {
     284           0 :     ThrowIfDisposed();
     285           0 :     mxSharedCanvas->drawPoint(aPoint,MergeViewState(aViewState),aRenderState);
     286           0 : }
     287             : 
     288             : 
     289             : 
     290             : 
     291           0 : void SAL_CALL PresenterCanvas::drawLine (
     292             :         const css::geometry::RealPoint2D& aStartPoint,
     293             :         const css::geometry::RealPoint2D& aEndPoint,
     294             :         const css::rendering::ViewState& aViewState,
     295             :         const css::rendering::RenderState& aRenderState)
     296             :         throw (css::lang::IllegalArgumentException, css::uno::RuntimeException, std::exception)
     297             : {
     298           0 :     ThrowIfDisposed();
     299           0 :     mxSharedCanvas->drawLine(aStartPoint,aEndPoint,MergeViewState(aViewState),aRenderState);
     300           0 : }
     301             : 
     302             : 
     303             : 
     304             : 
     305           0 : void SAL_CALL PresenterCanvas::drawBezier (
     306             :         const css::geometry::RealBezierSegment2D& aBezierSegment,
     307             :         const css::geometry::RealPoint2D& aEndPoint,
     308             :         const css::rendering::ViewState& aViewState,
     309             :         const css::rendering::RenderState& aRenderState)
     310             :         throw (css::lang::IllegalArgumentException, css::uno::RuntimeException, std::exception)
     311             : {
     312           0 :     ThrowIfDisposed();
     313           0 :     mxSharedCanvas->drawBezier(aBezierSegment,aEndPoint,MergeViewState(aViewState),aRenderState);
     314           0 : }
     315             : 
     316             : 
     317             : 
     318             : 
     319           0 : css::uno::Reference<css::rendering::XCachedPrimitive> SAL_CALL PresenterCanvas::drawPolyPolygon (
     320             :         const css::uno::Reference< css::rendering::XPolyPolygon2D >& xPolyPolygon,
     321             :         const css::rendering::ViewState& aViewState,
     322             :         const css::rendering::RenderState& aRenderState)
     323             :         throw (css::lang::IllegalArgumentException, css::uno::RuntimeException, std::exception)
     324             : {
     325           0 :     ThrowIfDisposed();
     326           0 :     return mxSharedCanvas->drawPolyPolygon(
     327           0 :         xPolyPolygon, MergeViewState(aViewState), aRenderState);
     328             : }
     329             : 
     330             : 
     331             : 
     332             : 
     333           0 : css::uno::Reference<css::rendering::XCachedPrimitive> SAL_CALL PresenterCanvas::strokePolyPolygon (
     334             :         const css::uno::Reference< css::rendering::XPolyPolygon2D >& xPolyPolygon,
     335             :         const css::rendering::ViewState& aViewState,
     336             :         const css::rendering::RenderState& aRenderState,
     337             :         const css::rendering::StrokeAttributes& aStrokeAttributes)
     338             :         throw (css::lang::IllegalArgumentException, css::uno::RuntimeException, std::exception)
     339             : {
     340           0 :     ThrowIfDisposed();
     341           0 :     return mxSharedCanvas->strokePolyPolygon(
     342           0 :         xPolyPolygon, MergeViewState(aViewState), aRenderState, aStrokeAttributes);
     343             : }
     344             : 
     345             : 
     346             : 
     347             : 
     348             : css::uno::Reference<css::rendering::XCachedPrimitive> SAL_CALL
     349           0 :         PresenterCanvas::strokeTexturedPolyPolygon (
     350             :             const css::uno::Reference< css::rendering::XPolyPolygon2D >& xPolyPolygon,
     351             :             const css::rendering::ViewState& aViewState,
     352             :             const css::rendering::RenderState& aRenderState,
     353             :             const css::uno::Sequence< css::rendering::Texture >& aTextures,
     354             :             const css::rendering::StrokeAttributes& aStrokeAttributes)
     355             :         throw (css::lang::IllegalArgumentException,
     356             :             css::rendering::VolatileContentDestroyedException,
     357             :             css::uno::RuntimeException, std::exception)
     358             : {
     359           0 :     ThrowIfDisposed();
     360           0 :     return mxSharedCanvas->strokeTexturedPolyPolygon(
     361           0 :         xPolyPolygon, MergeViewState(aViewState), aRenderState, aTextures, aStrokeAttributes);
     362             : }
     363             : 
     364             : 
     365             : 
     366             : 
     367             : css::uno::Reference<css::rendering::XCachedPrimitive> SAL_CALL
     368           0 :         PresenterCanvas::strokeTextureMappedPolyPolygon(
     369             :             const css::uno::Reference<css::rendering::XPolyPolygon2D >& xPolyPolygon,
     370             :             const css::rendering::ViewState& aViewState,
     371             :             const css::rendering::RenderState& aRenderState,
     372             :             const css::uno::Sequence<css::rendering::Texture>& aTextures,
     373             :             const css::uno::Reference<css::geometry::XMapping2D>& xMapping,
     374             :             const css::rendering::StrokeAttributes& aStrokeAttributes)
     375             :         throw (css::lang::IllegalArgumentException,
     376             :             css::rendering::VolatileContentDestroyedException,
     377             :             css::uno::RuntimeException, std::exception)
     378             : {
     379           0 :     ThrowIfDisposed();
     380           0 :     return mxSharedCanvas->strokeTextureMappedPolyPolygon(
     381             :         xPolyPolygon,
     382             :         MergeViewState(aViewState),
     383             :         aRenderState,
     384             :         aTextures,
     385             :         xMapping,
     386           0 :         aStrokeAttributes);
     387             : }
     388             : 
     389             : 
     390             : 
     391             : 
     392             : css::uno::Reference<css::rendering::XPolyPolygon2D> SAL_CALL
     393           0 :         PresenterCanvas::queryStrokeShapes(
     394             :             const css::uno::Reference<css::rendering::XPolyPolygon2D>& xPolyPolygon,
     395             :             const css::rendering::ViewState& aViewState,
     396             :             const css::rendering::RenderState& aRenderState,
     397             :             const css::rendering::StrokeAttributes& aStrokeAttributes)
     398             :         throw (css::lang::IllegalArgumentException, css::uno::RuntimeException, std::exception)
     399             : {
     400           0 :     ThrowIfDisposed();
     401           0 :     return mxSharedCanvas->queryStrokeShapes(
     402           0 :         xPolyPolygon, MergeViewState(aViewState), aRenderState, aStrokeAttributes);
     403             : }
     404             : 
     405             : 
     406             : 
     407             : 
     408             : css::uno::Reference<css::rendering::XCachedPrimitive> SAL_CALL
     409           0 :         PresenterCanvas::fillPolyPolygon(
     410             :             const css::uno::Reference<css::rendering::XPolyPolygon2D>& xPolyPolygon,
     411             :             const css::rendering::ViewState& aViewState,
     412             :             const css::rendering::RenderState& aRenderState)
     413             :         throw (css::lang::IllegalArgumentException,
     414             :             css::uno::RuntimeException, std::exception)
     415             : {
     416           0 :     ThrowIfDisposed();
     417           0 :     return mxSharedCanvas->fillPolyPolygon(
     418           0 :         xPolyPolygon, MergeViewState(aViewState), aRenderState);
     419             : }
     420             : 
     421             : 
     422             : 
     423             : 
     424             : css::uno::Reference<css::rendering::XCachedPrimitive> SAL_CALL
     425           0 :         PresenterCanvas::fillTexturedPolyPolygon(
     426             :             const css::uno::Reference<css::rendering::XPolyPolygon2D>& xPolyPolygon,
     427             :             const css::rendering::ViewState& aViewState,
     428             :             const css::rendering::RenderState& aRenderState,
     429             :             const css::uno::Sequence<css::rendering::Texture>& xTextures)
     430             :         throw (css::lang::IllegalArgumentException,
     431             :             css::rendering::VolatileContentDestroyedException,
     432             :             css::uno::RuntimeException, std::exception)
     433             : {
     434           0 :     ThrowIfDisposed();
     435           0 :     return mxSharedCanvas->fillTexturedPolyPolygon(
     436           0 :         xPolyPolygon, MergeViewState(aViewState), aRenderState, xTextures);
     437             : }
     438             : 
     439             : 
     440             : 
     441             : 
     442             : css::uno::Reference<css::rendering::XCachedPrimitive> SAL_CALL
     443           0 :         PresenterCanvas::fillTextureMappedPolyPolygon(
     444             :             const css::uno::Reference< css::rendering::XPolyPolygon2D >& xPolyPolygon,
     445             :             const css::rendering::ViewState& aViewState,
     446             :             const css::rendering::RenderState& aRenderState,
     447             :             const css::uno::Sequence< css::rendering::Texture >& xTextures,
     448             :             const css::uno::Reference< css::geometry::XMapping2D >& xMapping)
     449             :         throw (css::lang::IllegalArgumentException,
     450             :             css::rendering::VolatileContentDestroyedException,
     451             :             css::uno::RuntimeException, std::exception)
     452             : {
     453           0 :     ThrowIfDisposed();
     454           0 :     return mxSharedCanvas->fillTextureMappedPolyPolygon(
     455           0 :         xPolyPolygon, MergeViewState(aViewState), aRenderState, xTextures, xMapping);
     456             : }
     457             : 
     458             : 
     459             : 
     460             : 
     461             : css::uno::Reference<css::rendering::XCanvasFont> SAL_CALL
     462           0 :         PresenterCanvas::createFont(
     463             :             const css::rendering::FontRequest& aFontRequest,
     464             :             const css::uno::Sequence< css::beans::PropertyValue >& aExtraFontProperties,
     465             :             const css::geometry::Matrix2D& aFontMatrix)
     466             :         throw (css::lang::IllegalArgumentException,
     467             :             css::uno::RuntimeException, std::exception)
     468             : {
     469           0 :     ThrowIfDisposed();
     470           0 :     return mxSharedCanvas->createFont(
     471           0 :         aFontRequest, aExtraFontProperties, aFontMatrix);
     472             : }
     473             : 
     474             : 
     475             : 
     476             : 
     477             : css::uno::Sequence<css::rendering::FontInfo> SAL_CALL
     478           0 :         PresenterCanvas::queryAvailableFonts(
     479             :             const css::rendering::FontInfo& aFilter,
     480             :             const css::uno::Sequence< css::beans::PropertyValue >& aFontProperties)
     481             :         throw (css::lang::IllegalArgumentException, css::uno::RuntimeException, std::exception)
     482             : {
     483           0 :     ThrowIfDisposed();
     484           0 :     return mxSharedCanvas->queryAvailableFonts(aFilter, aFontProperties);
     485             : }
     486             : 
     487             : 
     488             : 
     489             : 
     490             : css::uno::Reference<css::rendering::XCachedPrimitive> SAL_CALL
     491           0 :         PresenterCanvas::drawText(
     492             :             const css::rendering::StringContext& aText,
     493             :             const css::uno::Reference< css::rendering::XCanvasFont >& xFont,
     494             :             const css::rendering::ViewState& aViewState,
     495             :             const css::rendering::RenderState& aRenderState,
     496             :             ::sal_Int8 nTextDirection)
     497             :         throw (css::lang::IllegalArgumentException, css::uno::RuntimeException, std::exception)
     498             : {
     499           0 :     ThrowIfDisposed();
     500           0 :     return mxSharedCanvas->drawText(
     501           0 :         aText, xFont, MergeViewState(aViewState), aRenderState, nTextDirection);
     502             : }
     503             : 
     504             : 
     505             : 
     506             : 
     507             : css::uno::Reference<css::rendering::XCachedPrimitive> SAL_CALL
     508           0 :         PresenterCanvas::drawTextLayout(
     509             :             const css::uno::Reference< css::rendering::XTextLayout >& xLayoutetText,
     510             :             const css::rendering::ViewState& aViewState,
     511             :             const css::rendering::RenderState& aRenderState)
     512             :         throw (css::lang::IllegalArgumentException, css::uno::RuntimeException, std::exception)
     513             : {
     514           0 :     ThrowIfDisposed();
     515           0 :     return mxSharedCanvas->drawTextLayout(
     516           0 :         xLayoutetText, MergeViewState(aViewState), aRenderState);
     517             : }
     518             : 
     519             : 
     520             : 
     521             : 
     522             : css::uno::Reference<css::rendering::XCachedPrimitive> SAL_CALL
     523           0 :         PresenterCanvas::drawBitmap(
     524             :             const css::uno::Reference< css::rendering::XBitmap >& xBitmap,
     525             :             const css::rendering::ViewState& aViewState,
     526             :             const css::rendering::RenderState& aRenderState)
     527             :         throw (css::lang::IllegalArgumentException,
     528             :             css::rendering::VolatileContentDestroyedException,
     529             :             css::uno::RuntimeException, std::exception)
     530             : {
     531           0 :     ThrowIfDisposed();
     532           0 :     return mxSharedCanvas->drawBitmap(
     533           0 :         xBitmap, MergeViewState(aViewState), aRenderState);
     534             : }
     535             : 
     536             : 
     537             : 
     538             : 
     539             : css::uno::Reference<css::rendering::XCachedPrimitive> SAL_CALL
     540           0 :         PresenterCanvas::drawBitmapModulated(
     541             :             const css::uno::Reference< css::rendering::XBitmap>& xBitmap,
     542             :             const css::rendering::ViewState& aViewState,
     543             :             const css::rendering::RenderState& aRenderState)
     544             :         throw (css::lang::IllegalArgumentException,
     545             :             css::rendering::VolatileContentDestroyedException,
     546             :             css::uno::RuntimeException, std::exception)
     547             : {
     548           0 :     ThrowIfDisposed();
     549           0 :     return mxSharedCanvas->drawBitmapModulated(
     550           0 :         xBitmap, MergeViewState(aViewState), aRenderState);
     551             : }
     552             : 
     553             : 
     554             : 
     555             : 
     556             : css::uno::Reference<css::rendering::XGraphicDevice> SAL_CALL
     557           0 :         PresenterCanvas::getDevice (void)
     558             :         throw (css::uno::RuntimeException, std::exception)
     559             : {
     560           0 :     ThrowIfDisposed();
     561           0 :     return mxSharedCanvas->getDevice();
     562             : }
     563             : 
     564             : 
     565             : 
     566             : 
     567             : //----- XSpriteCanvas ---------------------------------------------------------
     568             : 
     569             : Reference<rendering::XAnimatedSprite> SAL_CALL
     570           0 :     PresenterCanvas::createSpriteFromAnimation (
     571             :         const css::uno::Reference<css::rendering::XAnimation>& rAnimation)
     572             :     throw (css::lang::IllegalArgumentException, css::uno::RuntimeException, std::exception)
     573             : {
     574           0 :     ThrowIfDisposed();
     575             : 
     576           0 :     Reference<rendering::XSpriteCanvas> xSpriteCanvas (mxSharedCanvas, UNO_QUERY);
     577           0 :     if (xSpriteCanvas.is())
     578           0 :         return xSpriteCanvas->createSpriteFromAnimation(rAnimation);
     579             :     else
     580           0 :         return NULL;
     581             : }
     582             : 
     583             : 
     584             : 
     585             : 
     586             : Reference<rendering::XAnimatedSprite> SAL_CALL
     587           0 :     PresenterCanvas::createSpriteFromBitmaps (
     588             :         const css::uno::Sequence<
     589             :             css::uno::Reference< css::rendering::XBitmap > >& rAnimationBitmaps,
     590             :     ::sal_Int8 nInterpolationMode)
     591             :         throw (css::lang::IllegalArgumentException,
     592             :             css::rendering::VolatileContentDestroyedException,
     593             :             css::uno::RuntimeException, std::exception)
     594             : {
     595           0 :     ThrowIfDisposed();
     596             : 
     597           0 :     Reference<rendering::XSpriteCanvas> xSpriteCanvas (mxSharedCanvas, UNO_QUERY);
     598           0 :     if (xSpriteCanvas.is())
     599           0 :         return xSpriteCanvas->createSpriteFromBitmaps(rAnimationBitmaps, nInterpolationMode);
     600             :     else
     601           0 :         return NULL;
     602             : }
     603             : 
     604             : 
     605             : 
     606             : 
     607             : Reference<rendering::XCustomSprite> SAL_CALL
     608           0 :     PresenterCanvas::createCustomSprite (
     609             :         const css::geometry::RealSize2D& rSpriteSize)
     610             :     throw (css::lang::IllegalArgumentException, css::uno::RuntimeException, std::exception)
     611             : {
     612           0 :     ThrowIfDisposed();
     613             : 
     614           0 :     Reference<rendering::XSpriteCanvas> xSpriteCanvas (mxSharedCanvas, UNO_QUERY);
     615           0 :     if (xSpriteCanvas.is())
     616             :         return new PresenterCustomSprite(
     617             :             this,
     618           0 :             xSpriteCanvas->createCustomSprite(rSpriteSize),
     619             :             mxSharedWindow,
     620           0 :             rSpriteSize);
     621           0 :     else if (mxUpdateCanvas.is())
     622             :         return new PresenterCustomSprite(
     623             :             this,
     624           0 :             mxUpdateCanvas->createCustomSprite(rSpriteSize),
     625             :             mxUpdateWindow,
     626           0 :             rSpriteSize);
     627             :     else
     628           0 :         return NULL;
     629             : }
     630             : 
     631             : 
     632             : 
     633             : 
     634             : Reference<rendering::XSprite> SAL_CALL
     635           0 :     PresenterCanvas::createClonedSprite (
     636             :         const css::uno::Reference< css::rendering::XSprite >& rxOriginal)
     637             :     throw (css::lang::IllegalArgumentException, css::uno::RuntimeException, std::exception)
     638             : {
     639           0 :     ThrowIfDisposed();
     640             : 
     641           0 :     Reference<rendering::XSpriteCanvas> xSpriteCanvas (mxSharedCanvas, UNO_QUERY);
     642           0 :     if (xSpriteCanvas.is())
     643           0 :         return xSpriteCanvas->createClonedSprite(rxOriginal);
     644           0 :     if (mxUpdateCanvas.is())
     645           0 :         return mxUpdateCanvas->createClonedSprite(rxOriginal);
     646           0 :     return NULL;
     647             : }
     648             : 
     649             : 
     650             : 
     651             : 
     652           0 : sal_Bool SAL_CALL PresenterCanvas::updateScreen (sal_Bool bUpdateAll)
     653             :     throw (css::uno::RuntimeException, std::exception)
     654             : {
     655           0 :     ThrowIfDisposed();
     656             : 
     657           0 :     mbOffsetUpdatePending = true;
     658           0 :     if (mpUpdateRequester.get() != NULL)
     659             :     {
     660           0 :         mpUpdateRequester->RequestUpdate(bUpdateAll);
     661           0 :         return sal_True;
     662             :     }
     663             :     else
     664             :     {
     665           0 :         return sal_False;
     666             :     }
     667             : }
     668             : 
     669             : 
     670             : 
     671             : 
     672             : //----- XEventListener --------------------------------------------------------
     673             : 
     674           0 : void SAL_CALL PresenterCanvas::disposing (const css::lang::EventObject& rEvent)
     675             :     throw (css::uno::RuntimeException, std::exception)
     676             : {
     677           0 :     ThrowIfDisposed();
     678           0 :     if (rEvent.Source == mxWindow)
     679           0 :         mxWindow = NULL;
     680           0 : }
     681             : 
     682             : 
     683             : 
     684             : 
     685             : //----- XWindowListener -------------------------------------------------------
     686             : 
     687           0 : void SAL_CALL PresenterCanvas::windowResized (const css::awt::WindowEvent& rEvent)
     688             :         throw (css::uno::RuntimeException, std::exception)
     689             : {
     690             :     (void)rEvent;
     691           0 :     ThrowIfDisposed();
     692           0 :     mbOffsetUpdatePending = true;
     693           0 : }
     694             : 
     695             : 
     696             : 
     697             : 
     698           0 : void SAL_CALL PresenterCanvas::windowMoved (const css::awt::WindowEvent& rEvent)
     699             :     throw (css::uno::RuntimeException, std::exception)
     700             : {
     701             :     (void)rEvent;
     702           0 :     ThrowIfDisposed();
     703           0 :     mbOffsetUpdatePending = true;
     704           0 : }
     705             : 
     706             : 
     707             : 
     708             : 
     709           0 : void SAL_CALL PresenterCanvas::windowShown (const css::lang::EventObject& rEvent)
     710             :     throw (css::uno::RuntimeException, std::exception)
     711             : {
     712             :     (void)rEvent;
     713           0 :     ThrowIfDisposed();
     714           0 :     mbOffsetUpdatePending = true;
     715           0 : }
     716             : 
     717             : 
     718             : 
     719             : 
     720           0 : void SAL_CALL PresenterCanvas::windowHidden (const css::lang::EventObject& rEvent)
     721             :     throw (css::uno::RuntimeException, std::exception)
     722             : {
     723             :     (void)rEvent;
     724           0 :     ThrowIfDisposed();
     725           0 : }
     726             : 
     727             : 
     728             : 
     729             : 
     730             : //----- XBitmap ---------------------------------------------------------------
     731             : 
     732           0 : geometry::IntegerSize2D SAL_CALL PresenterCanvas::getSize (void)
     733             :     throw (RuntimeException, std::exception)
     734             : {
     735           0 :     ThrowIfDisposed();
     736             : 
     737           0 :     if (mxWindow.is())
     738             :     {
     739           0 :         const awt::Rectangle aWindowBox (mxWindow->getPosSize());
     740           0 :         return geometry::IntegerSize2D(aWindowBox.Width, aWindowBox.Height);
     741             :     }
     742             :     else
     743           0 :         return geometry::IntegerSize2D(0,0);
     744             : }
     745             : 
     746             : 
     747             : 
     748             : 
     749           0 : sal_Bool SAL_CALL PresenterCanvas::hasAlpha (void)
     750             :     throw (RuntimeException, std::exception)
     751             : {
     752           0 :     Reference<rendering::XBitmap> xBitmap (mxSharedCanvas, UNO_QUERY);
     753           0 :     if (xBitmap.is())
     754           0 :         return xBitmap->hasAlpha();
     755             :     else
     756           0 :         return sal_False;
     757             : }
     758             : 
     759             : 
     760             : 
     761             : 
     762           0 : Reference<rendering::XBitmap> SAL_CALL PresenterCanvas::getScaledBitmap(
     763             :     const css::geometry::RealSize2D& rNewSize,
     764             :     sal_Bool bFast)
     765             :     throw (css::uno::RuntimeException,
     766             :         css::lang::IllegalArgumentException,
     767             :         css::rendering::VolatileContentDestroyedException, std::exception)
     768             : {
     769             :     (void)rNewSize;
     770             :     (void)bFast;
     771             : 
     772           0 :     ThrowIfDisposed();
     773             : 
     774             :     // Not implemented.
     775             : 
     776           0 :     return NULL;
     777             : }
     778             : 
     779             : 
     780             : 
     781             : 
     782             : 
     783             : 
     784           0 : rendering::ViewState PresenterCanvas::MergeViewState (
     785             :     const rendering::ViewState& rViewState)
     786             : {
     787             :     // Make sure the offset is up-to-date.
     788           0 :     if (mbOffsetUpdatePending)
     789           0 :         maOffset = GetOffset(mxSharedWindow);
     790           0 :     return MergeViewState(rViewState, maOffset);
     791             : }
     792             : 
     793             : 
     794             : 
     795             : 
     796           0 : css::rendering::ViewState PresenterCanvas::MergeViewState (
     797             :     const css::rendering::ViewState& rViewState,
     798             :     const css::awt::Point& rOffset)
     799             : {
     800             :     // Early rejects.
     801           0 :     if ( ! mxSharedCanvas.is())
     802           0 :         return rViewState;
     803             : 
     804           0 :     Reference<rendering::XGraphicDevice> xDevice (mxSharedCanvas->getDevice());
     805           0 :     if ( ! xDevice.is())
     806           0 :         return rViewState;
     807             : 
     808             :     // Create a modifiable copy of the given view state.
     809           0 :     rendering::ViewState aViewState (rViewState);
     810             : 
     811             :     // Prepare the local clip rectangle.
     812           0 :     ::basegfx::B2DRectangle aWindowRange (GetClipRectangle(aViewState.AffineTransform, rOffset));
     813             : 
     814             :     // Adapt the offset of the view state.
     815           0 :     aViewState.AffineTransform.m02 += rOffset.X;
     816           0 :     aViewState.AffineTransform.m12 += rOffset.Y;
     817             : 
     818             :     // Adapt the clip polygon.
     819           0 :     if ( ! aViewState.Clip.is())
     820             :     {
     821             :         // Cancel out the later multiplication with the view state
     822             :         // transformation.
     823           0 :         aViewState.Clip = ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(
     824             :             xDevice,
     825           0 :             ::basegfx::B2DPolyPolygon(::basegfx::tools::createPolygonFromRect(aWindowRange)));
     826             :     }
     827             :     else
     828             :     {
     829             :         // Have to compute the intersection of the given clipping polygon in
     830             :         // the view state and the local clip rectangle.
     831             : 
     832             :         // Clip the view state clipping polygon against the local clip rectangle.
     833             :         const ::basegfx::B2DPolyPolygon aClipPolygon (
     834             :             ::basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D(
     835           0 :                 aViewState.Clip));
     836             :         const ::basegfx::B2DPolyPolygon aClippedClipPolygon (
     837             :             ::basegfx::tools::clipPolyPolygonOnRange(
     838             :                 aClipPolygon,
     839             :                 aWindowRange,
     840             :                 true, /* bInside */
     841           0 :                 false /* bStroke */));
     842             : 
     843           0 :         aViewState.Clip = ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(
     844             :             xDevice,
     845           0 :             aClippedClipPolygon);
     846             :     }
     847             : 
     848           0 :     return aViewState;
     849             : }
     850             : 
     851             : 
     852             : 
     853             : 
     854           0 : awt::Point PresenterCanvas::GetOffset (const Reference<awt::XWindow>& rxBaseWindow)
     855             : {
     856           0 :     mbOffsetUpdatePending = false;
     857           0 :     if (mxWindow.is() && rxBaseWindow.is())
     858             :     {
     859           0 :         ::Window* pWindow = VCLUnoHelper::GetWindow(mxWindow);
     860           0 :         ::Window* pSharedWindow = VCLUnoHelper::GetWindow(rxBaseWindow);
     861           0 :         if (pWindow!=NULL && pSharedWindow!=NULL)
     862             :         {
     863           0 :             Rectangle aBox = pWindow->GetWindowExtentsRelative(pSharedWindow);
     864             : 
     865             :             // Calculate offset of this canvas with respect to the shared
     866             :             // canvas.
     867           0 :             return awt::Point(aBox.Left(), aBox.Top());
     868             :         }
     869             :     }
     870             : 
     871           0 :     return awt::Point(0, 0);
     872             : }
     873             : 
     874             : 
     875             : 
     876             : 
     877           0 : ::basegfx::B2DRectangle PresenterCanvas::GetClipRectangle (
     878             :     const css::geometry::AffineMatrix2D& rViewTransform,
     879             :     const awt::Point& rOffset)
     880             : {
     881           0 :     ::basegfx::B2DRectangle aClipRectangle;
     882             : 
     883           0 :     ::Window* pWindow = VCLUnoHelper::GetWindow(mxWindow);
     884           0 :     if (pWindow == NULL)
     885           0 :         return ::basegfx::B2DRectangle();
     886             : 
     887           0 :     ::Window* pSharedWindow = VCLUnoHelper::GetWindow(mxSharedWindow);
     888           0 :     if (pSharedWindow == NULL)
     889           0 :         return ::basegfx::B2DRectangle();
     890             : 
     891             :     // Get the bounding box of the window and create a range in the
     892             :     // coordinate system of the child window.
     893           0 :     Rectangle aLocalClip;
     894           0 :     if (maClipRectangle.Width <= 0 || maClipRectangle.Height <= 0)
     895             :     {
     896             :         // No clip rectangle has been set via SetClip by the pane.
     897             :         // Use the window extents instead.
     898           0 :         aLocalClip = pWindow->GetWindowExtentsRelative(pSharedWindow);
     899             :     }
     900             :     else
     901             :     {
     902             :         // Use a previously given clip rectangle.
     903             :         aLocalClip = Rectangle(
     904             :             maClipRectangle.X + rOffset.X,
     905             :             maClipRectangle.Y + rOffset.Y,
     906           0 :             maClipRectangle.X + maClipRectangle.Width + rOffset.X,
     907           0 :             maClipRectangle.Y + maClipRectangle.Height + rOffset.Y);
     908             :     }
     909             : 
     910             :     // The local clip rectangle is used to clip the view state clipping
     911             :     // polygon.
     912             :     ::basegfx::B2DRectangle aWindowRectangle (
     913           0 :         aLocalClip.Left() - rOffset.X,
     914           0 :         aLocalClip.Top() - rOffset.Y,
     915           0 :         aLocalClip.Right() - rOffset.X + 1,
     916           0 :         aLocalClip.Bottom() - rOffset.Y + 1);
     917             : 
     918             :     // Calculate the inverted view state transformation to cancel out a
     919             :     // later transformation of the local clip polygon with the view state
     920             :     // transformation.
     921           0 :     ::basegfx::B2DHomMatrix aInvertedViewStateTransformation;
     922             :     ::basegfx::unotools::homMatrixFromAffineMatrix(
     923             :         aInvertedViewStateTransformation,
     924           0 :         rViewTransform);
     925           0 :     if (aInvertedViewStateTransformation.invert())
     926             :     {
     927             :         // Cancel out the later multiplication with the view state
     928             :         // transformation.
     929           0 :         aWindowRectangle.transform(aInvertedViewStateTransformation);
     930             :     }
     931             : 
     932           0 :     return aWindowRectangle;
     933             : }
     934             : 
     935             : 
     936             : 
     937           0 : Reference<rendering::XPolyPolygon2D> PresenterCanvas::UpdateSpriteClip (
     938             :     const Reference<rendering::XPolyPolygon2D>& rxOriginalClip,
     939             :     const geometry::RealPoint2D& rLocation,
     940             :     const geometry::RealSize2D& rSize)
     941             : {
     942             :     (void)rSize;
     943             : 
     944             :     // Check used resources and just return the original clip when not
     945             :     // every one of them is available.
     946           0 :     if ( ! mxWindow.is())
     947           0 :         return rxOriginalClip;
     948             : 
     949           0 :     Reference<rendering::XGraphicDevice> xDevice (mxSharedCanvas->getDevice());
     950           0 :     if ( ! xDevice.is())
     951           0 :         return rxOriginalClip;
     952             : 
     953             :     // Determine the bounds of the clip rectangle (the window border) in the
     954             :     // coordinate system of the sprite.
     955           0 :     const awt::Rectangle aWindowBox (mxWindow->getPosSize());
     956           0 :     const double nMinX (-rLocation.X);
     957           0 :     const double nMinY (-rLocation.Y);
     958           0 :     const double nMaxX (aWindowBox.Width-rLocation.X);
     959           0 :     const double nMaxY (aWindowBox.Height-rLocation.Y);
     960             : 
     961             :     // Create a clip polygon.
     962           0 :     Reference<rendering::XPolyPolygon2D> xPolygon;
     963           0 :     if (rxOriginalClip.is())
     964             :     {
     965             :         // Combine the original clip with the window clip.
     966             :         const ::basegfx::B2DPolyPolygon aOriginalClip (
     967           0 :             ::basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D(rxOriginalClip));
     968           0 :         ::basegfx::B2DRectangle aWindowRange (nMinX, nMinY, nMaxX, nMaxY);
     969             :         const ::basegfx::B2DPolyPolygon aClippedClipPolygon (
     970             :             ::basegfx::tools::clipPolyPolygonOnRange(
     971             :                 aOriginalClip,
     972             :                 aWindowRange,
     973             :                 true, /* bInside */
     974           0 :                 false /* bStroke */));
     975           0 :         xPolygon = ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(
     976             :             xDevice,
     977           0 :             aClippedClipPolygon);
     978             :     }
     979             :     else
     980             :     {
     981             :         // Create a new clip polygon from the window clip rectangle.
     982           0 :         Sequence<Sequence<geometry::RealPoint2D> > aPoints (1);
     983           0 :         aPoints[0] = Sequence<geometry::RealPoint2D>(4);
     984           0 :         aPoints[0][0] = geometry::RealPoint2D(nMinX,nMinY);
     985           0 :         aPoints[0][1] = geometry::RealPoint2D(nMaxX,nMinY);
     986           0 :         aPoints[0][2] = geometry::RealPoint2D(nMaxX,nMaxY);
     987           0 :         aPoints[0][3] = geometry::RealPoint2D(nMinX,nMaxY);
     988             :         Reference<rendering::XLinePolyPolygon2D> xLinePolygon(
     989           0 :             xDevice->createCompatibleLinePolyPolygon(aPoints));
     990           0 :         if (xLinePolygon.is())
     991           0 :             xLinePolygon->setClosed(0, sal_True);
     992           0 :         xPolygon = Reference<rendering::XPolyPolygon2D>(xLinePolygon, UNO_QUERY);
     993             :     }
     994             : 
     995           0 :     return xPolygon;
     996             : }
     997             : 
     998             : 
     999             : 
    1000             : 
    1001           0 : void PresenterCanvas::ThrowIfDisposed (void)
    1002             :     throw (css::lang::DisposedException)
    1003             : {
    1004           0 :     if (rBHelper.bDisposed || rBHelper.bInDispose || ! mxSharedCanvas.is())
    1005             :     {
    1006             :         throw lang::DisposedException ("PresenterCanvas object has already been disposed",
    1007           0 :             static_cast<uno::XWeak*>(this));
    1008             :     }
    1009           0 : }
    1010             : 
    1011             : 
    1012             : 
    1013             : 
    1014             : //===== PresenterCustomSprite =================================================
    1015             : 
    1016             : 
    1017           0 : PresenterCustomSprite::PresenterCustomSprite (
    1018             :     const rtl::Reference<PresenterCanvas>& rpCanvas,
    1019             :     const Reference<rendering::XCustomSprite>& rxSprite,
    1020             :     const Reference<awt::XWindow>& rxBaseWindow,
    1021             :     const css::geometry::RealSize2D& rSpriteSize)
    1022             :     : PresenterCustomSpriteInterfaceBase(m_aMutex),
    1023             :       mpCanvas(rpCanvas),
    1024             :       mxSprite(rxSprite),
    1025             :       mxBaseWindow(rxBaseWindow),
    1026             :       maPosition(0,0),
    1027           0 :       maSpriteSize(rSpriteSize)
    1028             : {
    1029           0 : }
    1030             : 
    1031             : 
    1032             : 
    1033             : 
    1034           0 : PresenterCustomSprite::~PresenterCustomSprite (void)
    1035             : {
    1036           0 : }
    1037             : 
    1038             : 
    1039             : 
    1040             : 
    1041           0 : void SAL_CALL PresenterCustomSprite::disposing (void)
    1042             :     throw (RuntimeException)
    1043             : {
    1044           0 :     Reference<XComponent> xComponent (mxSprite, UNO_QUERY);
    1045           0 :     mxSprite = NULL;
    1046           0 :     if (xComponent.is())
    1047           0 :         xComponent->dispose();
    1048           0 :     mpCanvas = rtl::Reference<PresenterCanvas>();
    1049           0 : }
    1050             : 
    1051             : 
    1052             : 
    1053             : 
    1054             : //----- XSprite ---------------------------------------------------------------
    1055             : 
    1056           0 : void SAL_CALL PresenterCustomSprite::setAlpha (const double nAlpha)
    1057             :     throw (lang::IllegalArgumentException,RuntimeException, std::exception)
    1058             : {
    1059           0 :     ThrowIfDisposed();
    1060           0 :     mxSprite->setAlpha(nAlpha);
    1061           0 : }
    1062             : 
    1063             : 
    1064             : 
    1065             : 
    1066           0 : void SAL_CALL PresenterCustomSprite::move (
    1067             :     const geometry::RealPoint2D& rNewPos,
    1068             :     const rendering::ViewState& rViewState,
    1069             :     const rendering::RenderState& rRenderState)
    1070             :     throw (lang::IllegalArgumentException,RuntimeException, std::exception)
    1071             : {
    1072           0 :     ThrowIfDisposed();
    1073           0 :     maPosition = rNewPos;
    1074           0 :     mxSprite->move(
    1075             :         rNewPos,
    1076           0 :         mpCanvas->MergeViewState(rViewState, mpCanvas->GetOffset(mxBaseWindow)),
    1077           0 :         rRenderState);
    1078             :     // Clip sprite against window bounds.  This call is necessary because
    1079             :     // sprite clipping is done in the corrdinate system of the sprite.
    1080             :     // Therefore, after each change of the sprites location the window
    1081             :     // bounds have to be transformed into the sprites coordinate system.
    1082           0 :     clip(NULL);
    1083           0 : }
    1084             : 
    1085             : 
    1086             : 
    1087             : 
    1088           0 : void SAL_CALL PresenterCustomSprite::transform (const geometry::AffineMatrix2D& rTransformation)
    1089             :     throw (lang::IllegalArgumentException,RuntimeException, std::exception)
    1090             : {
    1091           0 :     ThrowIfDisposed();
    1092           0 :     mxSprite->transform(rTransformation);
    1093           0 : }
    1094             : 
    1095             : 
    1096             : 
    1097             : 
    1098           0 : void SAL_CALL PresenterCustomSprite::clip (const Reference<rendering::XPolyPolygon2D>& rxClip)
    1099             :     throw (RuntimeException, std::exception)
    1100             : {
    1101           0 :     ThrowIfDisposed();
    1102             :     // The clip region is expected in the coordinate system of the sprite.
    1103             :     // UpdateSpriteClip() integrates the window bounds, transformed into the
    1104             :     // sprites coordinate system, with the given clip.
    1105           0 :     mxSprite->clip(mpCanvas->UpdateSpriteClip(rxClip, maPosition, maSpriteSize));
    1106           0 : }
    1107             : 
    1108             : 
    1109             : 
    1110             : 
    1111           0 : void SAL_CALL PresenterCustomSprite::setPriority (const double nPriority)
    1112             :     throw (RuntimeException, std::exception)
    1113             : {
    1114           0 :     ThrowIfDisposed();
    1115           0 :     mxSprite->setPriority(nPriority);
    1116           0 : }
    1117             : 
    1118             : 
    1119             : 
    1120           0 : void SAL_CALL PresenterCustomSprite::show (void)
    1121             :     throw (RuntimeException, std::exception)
    1122             : {
    1123           0 :     ThrowIfDisposed();
    1124           0 :     mxSprite->show();
    1125           0 : }
    1126             : 
    1127             : 
    1128             : 
    1129             : 
    1130           0 : void SAL_CALL PresenterCustomSprite::hide (void)
    1131             :     throw (RuntimeException, std::exception)
    1132             : {
    1133           0 :     ThrowIfDisposed();
    1134           0 :     mxSprite->hide();
    1135           0 : }
    1136             : 
    1137             : 
    1138             : 
    1139             : 
    1140             : //----- XCustomSprite ---------------------------------------------------------
    1141             : 
    1142           0 : Reference<rendering::XCanvas> PresenterCustomSprite::getContentCanvas (void)
    1143             :     throw (RuntimeException, std::exception)
    1144             : {
    1145           0 :     ThrowIfDisposed();
    1146           0 :     return mxSprite->getContentCanvas();
    1147             : }
    1148             : 
    1149             : 
    1150             : 
    1151             : 
    1152             : 
    1153             : 
    1154           0 : void PresenterCustomSprite::ThrowIfDisposed (void)
    1155             :     throw (css::lang::DisposedException)
    1156             : {
    1157           0 :     if (rBHelper.bDisposed || rBHelper.bInDispose || ! mxSprite.is())
    1158             :     {
    1159             :         throw lang::DisposedException ("PresenterCustomSprite object has already been disposed",
    1160           0 :             static_cast<uno::XWeak*>(this));
    1161             :     }
    1162           0 : }
    1163             : 
    1164             : 
    1165             : 
    1166             : 
    1167             : } } // end of namespace ::sd::presenter
    1168             : 
    1169             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10