canvascustomspritebase.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#pragma once
 
#include <com/sun/star/rendering/XCanvas.hpp>
 
#include <basegfx/point/b2dpoint.hxx>
#include <basegfx/vector/b2dvector.hxx>
#include <basegfx/range/b2drange.hxx>
#include <base/integerbitmapbase.hxx>
#include <base/bitmapcanvasbase.hxx>
 
namespace com::sun::star::rendering { class XPolyPolygon2D; }
 
namespace canvas
{
    template< class Base,
              class SpriteHelper,
              class CanvasHelper,
              class Mutex=::osl::MutexGuard,
              class UnambiguousBase = css::uno::XInterface > class CanvasCustomSpriteBase :
        public IntegerBitmapBase< BitmapCanvasBase2<Base, CanvasHelper, Mutex, UnambiguousBase> >
    {
    public:
        typedef IntegerBitmapBase< BitmapCanvasBase2<Base, CanvasHelper, Mutex, UnambiguousBase> > BaseType;
 
        CanvasCustomSpriteBase() :
            maSpriteHelper()
        {
        }
 
        virtual void disposeThis() override
        {
            typename BaseType::MutexType aGuard( BaseType::m_aMutex );
 
            maSpriteHelper.disposing();
 
            // pass on to base class
            BaseType::disposeThis();
        }
 
        // XCanvas: selectively override base's methods here, for opacity tracking
        virtual void SAL_CALL clear() override
        {
            typename BaseType::MutexType aGuard( BaseType::m_aMutex );
 
            maSpriteHelper.clearingContent( this );
 
            // and forward to base class, which handles the actual rendering
            return BaseType::clear();
        }
 
        virtual css::uno::Reference< css::rendering::XCachedPrimitive > SAL_CALL
            drawBitmap( const css::uno::Reference< css::rendering::XBitmap >&              xBitmap,
                        const css::rendering::ViewState&                                   viewState,
                        const css::rendering::RenderState&                                 renderState ) override
        {
            tools::verifyArgs(xBitmap, viewState, renderState,
                              __func__,
                              static_cast< typename BaseType::UnambiguousBaseType* >(this));
 
            typename BaseType::MutexType aGuard( BaseType::m_aMutex );
 
            maSpriteHelper.checkDrawBitmap( this, xBitmap, viewState, renderState );
 
            // and forward to base class, which handles the actual rendering
            return BaseType::drawBitmap( xBitmap,
                                         viewState,
                                         renderState );
        }
 
        // TODO(F3): If somebody uses the XIntegerBitmap methods to
        // clear pixel (setting alpha != 1.0 there), or a compositing
        // mode results in similar alpha, maSpriteHelper might
        // erroneously report fully opaque sprites. Effectively, all
        // render methods must be overridden here; or better,
        // functionality provided at the baseclass.
 
        // XSprite
        virtual void SAL_CALL setAlpha( double alpha ) override
        {
            tools::verifyRange( alpha, 0.0, 1.0 );
 
            typename BaseType::MutexType aGuard( BaseType::m_aMutex );
 
            maSpriteHelper.setAlpha( this, alpha );
        }
 
        virtual void SAL_CALL move( const css::geometry::RealPoint2D&  aNewPos,
                                    const css::rendering::ViewState&   viewState,
                                    const css::rendering::RenderState& renderState ) override
        {
            tools::verifyArgs(aNewPos, viewState, renderState,
                              __func__,
                              static_cast< typename BaseType::UnambiguousBaseType* >(this));
 
            typename BaseType::MutexType aGuard( BaseType::m_aMutex );
 
            maSpriteHelper.move( this, aNewPos, viewState, renderState );
        }
 
        virtual void SAL_CALL transform( const css::geometry::AffineMatrix2D& aTransformation ) override
        {
            tools::verifyArgs(aTransformation,
                              __func__,
                              static_cast< typename BaseType::UnambiguousBaseType* >(this));
 
            typename BaseType::MutexType aGuard( BaseType::m_aMutex );
 
            maSpriteHelper.transform( this, aTransformation );
        }
 
        virtual void SAL_CALL clip( const css::uno::Reference< css::rendering::XPolyPolygon2D >& aClip ) override
        {
            // NULL xClip explicitly allowed here (to clear clipping)
 
            typename BaseType::MutexType aGuard( BaseType::m_aMutex );
 
            maSpriteHelper.clip( this, aClip );
        }
 
        virtual void SAL_CALL setPriority( double nPriority ) override
        {
            typename BaseType::MutexType aGuard( BaseType::m_aMutex );
 
            maSpriteHelper.setPriority( this, nPriority );
        }
 
        virtual void SAL_CALL show() override
        {
            typename BaseType::MutexType aGuard( BaseType::m_aMutex );
 
            maSpriteHelper.show( this );
        }
 
        virtual void SAL_CALL hide() override
        {
            typename BaseType::MutexType aGuard( BaseType::m_aMutex );
 
            maSpriteHelper.hide( this );
        }
 
        // XCustomSprite
        virtual css::uno::Reference< css::rendering::XCanvas > SAL_CALL
            getContentCanvas() override
        {
            typename BaseType::MutexType aGuard( BaseType::m_aMutex );
 
            return this;
        }
 
        // Sprite
        virtual bool isAreaUpdateOpaque( const ::basegfx::B2DRange& rUpdateArea ) const override
        {
            typename BaseType::MutexType aGuard( BaseType::m_aMutex );
 
            return maSpriteHelper.isAreaUpdateOpaque( rUpdateArea );
        }
 
        virtual bool isContentChanged() const override
        {
            typename BaseType::MutexType aGuard( BaseType::m_aMutex );
 
            return BaseType::mbSurfaceDirty;
        }
 
        virtual ::basegfx::B2DPoint getPosPixel() const override
        {
            typename BaseType::MutexType aGuard( BaseType::m_aMutex );
 
            return maSpriteHelper.getPosPixel();
        }
 
        virtual ::basegfx::B2DVector getSizePixel() const override
        {
            typename BaseType::MutexType aGuard( BaseType::m_aMutex );
 
            return maSpriteHelper.getSizePixel();
        }
 
        virtual ::basegfx::B2DRange getUpdateArea() const override
        {
            typename BaseType::MutexType aGuard( BaseType::m_aMutex );
 
            return maSpriteHelper.getUpdateArea();
        }
 
        virtual double getPriority() const override
        {
            typename BaseType::MutexType aGuard( BaseType::m_aMutex );
 
            return maSpriteHelper.getPriority();
        }
 
    protected:
        SpriteHelper maSpriteHelper;
    };
}
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */