Adding upstream version 4:24.2.0.upstream/4%24.2.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 261 insertions, 0 deletions

diff --git a/canvas/inc/base/canvascustomspritebase.hxx b/canvas/inc/base/canvascustomspritebase.hxx
new file mode 100644
index 0000000000..8379a54d93
--- /dev/null
+++ b/canvas/inc/base/canvascustomspritebase.hxx
@@ -0,0 +1,261 @@
+/* -*- 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
+{
+    /** Helper template to handle XCustomSprite method forwarding to
+        CanvasCustomSpriteHelper
+
+        Use this helper to handle the XCustomSprite part of your
+        implementation.
+
+        @tpl Base
+        Base class to use, most probably one of the
+        WeakComponentImplHelperN templates with the appropriate
+        interfaces. At least XCustomSprite and Sprite should be among
+        them (why else would you use this template, then?). Base class
+        must have a Base( const Mutex& ) constructor (like the
+        WeakComponentImplHelperN templates have).
+
+        @tpl SpriteHelper
+        Sprite helper implementation for the backend in question
+
+        @tpl CanvasHelper
+        Canvas helper implementation for the backend in question
+
+        @tpl Mutex
+        Lock strategy to use. Defaults to using the
+        BaseMutex-provided lock.  Every time one of the methods is
+        entered, an object of type Mutex is created with m_aMutex as
+        the sole parameter, and destroyed again when the method scope
+        is left.
+
+        @tpl UnambiguousBase
+        Optional unambiguous base class for XInterface of Base. It's
+        sometimes necessary to specify this parameter, e.g. if Base
+        derives from multiple UNO interface (were each provides its
+        own version of XInterface, making the conversion ambiguous)
+
+        @see CanvasCustomSpriteHelper for further contractual
+        requirements towards the SpriteHelper type, and some examples.
+     */
+    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()
+        {
+        }
+
+        /** Object is being disposed.
+
+            Called from the cppu helper base, to notify disposal of
+            this object. Already releases all internal references.
+
+            @derive when overriding this method in derived classes,
+            <em>always</em> call the base class' method!
+         */
+        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: */