slideshow/test/testview.cxx

   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 <sal/types.h>
  21
  22 #include <cppuhelper/compbase.hxx>
  23 #include <cppuhelper/basemutex.hxx>
  24 #include <comphelper/make_shared_from_uno.hxx>
  25
  26 #include <basegfx/matrix/b2dhommatrix.hxx>
  27 #include <basegfx/range/b1drange.hxx>
  28 #include <basegfx/polygon/b2dpolypolygon.hxx>
  29
  30 #include "tests.hxx"
  31 #include <view.hxx>
  32 #include <com/sun/star/presentation/XSlideShowView.hpp>
  33
  34 #include <vector>
  35 #include <exception>
  36
  37
  38 namespace target = slideshow::internal;
  39 using namespace ::com::sun::star;
  40
  41 // our test view subject
  42 typedef ::cppu::WeakComponentImplHelper< presentation::XSlideShowView > ViewBase;
  43
  44 namespace {
  45
  46 class ImplTestView : public TestView,
  47                      private cppu::BaseMutex,
  48                      public ViewBase
  49 {
  50     mutable std::vector<std::pair<basegfx::B2DVector,double> > maCreatedSprites;
  51     mutable std::vector<TestViewSharedPtr>                     maViewLayers;
  52     basegfx::B2DRange                                  maBounds;
  53     basegfx::B1DRange                                  maPriority;
  54     bool                                               mbIsClipSet;
  55     bool                                               mbIsClipEmptied;
  56     bool                                               mbDisposed;
  57
  58
  59 public:
  60     ImplTestView() :
  61         ViewBase(m_aMutex),
  62         maCreatedSprites(),
  63         maViewLayers(),
  64         maBounds(),
  65         maPriority(),
  66         mbIsClipSet(false),
  67         mbIsClipEmptied(false),
  68         mbDisposed( false )
  69     {
  70     }
  71
  72     // XSlideShowView
  73     virtual uno::Reference< rendering::XSpriteCanvas > SAL_CALL getCanvas(  ) override
  74     {
  75         return uno::Reference< rendering::XSpriteCanvas >();
  76     }
  77
  78     virtual void SAL_CALL clear(  ) override
  79     {
  80     }
  81
  82     virtual geometry::AffineMatrix2D SAL_CALL getTransformation(  ) override
  83     {
  84         return geometry::AffineMatrix2D();
  85     }
  86
  87     virtual ::css::geometry::IntegerSize2D SAL_CALL getTranslationOffset() override
  88     {
  89         return geometry::IntegerSize2D();
  90     }
  91
  92     virtual geometry::IntegerSize2D getTranslationOffset() const override
  93     {
  94         return geometry::IntegerSize2D();
  95     }
  96
  97     virtual void SAL_CALL addTransformationChangedListener( const uno::Reference< util::XModifyListener >& ) override
  98     {
  99     }
 100
 101     virtual void SAL_CALL removeTransformationChangedListener( const uno::Reference< util::XModifyListener >& ) override
 102     {
 103     }
 104
 105     virtual void SAL_CALL addPaintListener( const uno::Reference< awt::XPaintListener >& ) override
 106     {
 107     }
 108
 109     virtual void SAL_CALL removePaintListener( const uno::Reference< awt::XPaintListener >& ) override
 110     {
 111     }
 112
 113     virtual void SAL_CALL addMouseListener( const uno::Reference< awt::XMouseListener >& ) override
 114     {
 115     }
 116
 117     virtual void SAL_CALL removeMouseListener( const uno::Reference< awt::XMouseListener >& ) override
 118     {
 119     }
 120
 121     virtual void SAL_CALL addMouseMotionListener( const uno::Reference< awt::XMouseMotionListener >& ) override
 122     {
 123     }
 124
 125     virtual void SAL_CALL removeMouseMotionListener( const uno::Reference< awt::XMouseMotionListener >& ) override
 126     {
 127     }
 128
 129     virtual void SAL_CALL setMouseCursor( ::sal_Int16 ) override
 130     {
 131     }
 132
 133     virtual awt::Rectangle SAL_CALL getCanvasArea(  ) override
 134     {
 135         return awt::Rectangle(0,0,100,100);
 136     }
 137
 138     virtual basegfx::B2DRange getBounds() const override
 139     {
 140         return maBounds;
 141     }
 142
 143     virtual std::vector<std::shared_ptr<TestView> > getViewLayers() const override
 144     {
 145         return maViewLayers;
 146     }
 147
 148     // ViewLayer
 149     virtual bool isOnView(target::ViewSharedPtr const& /*rView*/) const override
 150     {
 151         return true;
 152     }
 153
 154     virtual ::cppcanvas::CanvasSharedPtr getCanvas() const override
 155     {
 156         return ::cppcanvas::CanvasSharedPtr();
 157     }
 158
 159     virtual ::cppcanvas::CustomSpriteSharedPtr createSprite( const ::basegfx::B2DSize& rSpriteSizePixel,
 160                                                              double                    nPriority ) const override
 161     {
 162         basegfx::B2DVector aSpriteSizeVector(rSpriteSizePixel.getWidth(), rSpriteSizePixel.getHeight());
 163         maCreatedSprites.emplace_back(aSpriteSizeVector, nPriority);
 164
 165         return ::cppcanvas::CustomSpriteSharedPtr();
 166     }
 167
 168     virtual void setPriority( const basegfx::B1DRange& rRange ) override
 169     {
 170         maPriority = rRange;
 171     }
 172
 173     virtual ::basegfx::B2DHomMatrix getTransformation() const override
 174     {
 175         return ::basegfx::B2DHomMatrix();
 176     }
 177
 178     virtual ::basegfx::B2DHomMatrix getSpriteTransformation() const override
 179     {
 180         return ::basegfx::B2DHomMatrix();
 181     }
 182
 183     virtual void setClip( const ::basegfx::B2DPolyPolygon& rClip ) override
 184     {
 185         if( !mbIsClipSet )
 186         {
 187             if( rClip.count() > 0 )
 188                 mbIsClipSet = true;
 189         }
 190         else if( !mbIsClipEmptied )
 191         {
 192             if( rClip.count() == 0 )
 193                 mbIsClipEmptied = true;
 194         }
 195         else if( rClip.count() > 0 )
 196         {
 197             mbIsClipSet = true;
 198             mbIsClipEmptied = false;
 199         }
 200         else
 201         {
 202             // unexpected call
 203             throw std::exception();
 204         }
 205     }
 206
 207     virtual bool resize( const basegfx::B2DRange& rArea ) override
 208     {
 209         const bool bRet( maBounds != rArea );
 210         maBounds = rArea;
 211         return bRet;
 212     }
 213
 214     virtual target::ViewLayerSharedPtr createViewLayer(
 215         const basegfx::B2DRange& rLayerBounds ) const override
 216     {
 217         maViewLayers.push_back( std::make_shared<ImplTestView>());
 218         maViewLayers.back()->resize( rLayerBounds );
 219
 220         return maViewLayers.back();
 221     }
 222
 223     virtual bool updateScreen() const override
 224     {
 225         // misusing updateScreen for state reporting
 226         return !mbDisposed;
 227     }
 228
 229     virtual bool paintScreen() const override
 230     {
 231         // misusing updateScreen for state reporting
 232         return !mbDisposed;
 233     }
 234
 235     virtual void clear() const override
 236     {
 237     }
 238
 239     virtual void clearAll() const override
 240     {
 241     }
 242
 243     virtual void setViewSize( const ::basegfx::B2DSize& ) override
 244     {
 245     }
 246
 247     virtual void setCursorShape( sal_Int16 /*nPointerShape*/ ) override
 248     {
 249     }
 250
 251     virtual uno::Reference< presentation::XSlideShowView > getUnoView() const override
 252     {
 253         return uno::Reference< presentation::XSlideShowView >( const_cast<ImplTestView*>(this) );
 254     }
 255
 256     virtual void _dispose() override
 257     {
 258         mbDisposed = true;
 259     }
 260
 261     virtual bool isSoundEnabled() const override
 262     {
 263         return true;
 264     }
 265
 266     virtual void setIsSoundEnabled (const bool /*bValue*/) override
 267     {
 268     }
 269 };
 270
 271 }
 272
 273 TestViewSharedPtr createTestView()
 274 {
 275     return TestViewSharedPtr(
 276         comphelper::make_shared_from_UNO(
 277             new ImplTestView()) );
 278 }
 279
 280 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */