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

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

1 files changed, 407 insertions, 0 deletions

diff --git a/canvas/inc/spriteredrawmanager.hxx b/canvas/inc/spriteredrawmanager.hxx
new file mode 100644
index 000000000..8e4e49e7a
--- /dev/null
+++ b/canvas/inc/spriteredrawmanager.hxx
@@ -0,0 +1,407 @@
+/* -*- 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 <basegfx/range/b2dconnectedranges.hxx>
+#include <basegfx/point/b2dpoint.hxx>
+#include <basegfx/vector/b2dvector.hxx>
+#include <basegfx/range/b2drange.hxx>
+#include <basegfx/range/b2drectangle.hxx>
+
+#include <utility>
+#include <vector>
+#include <algorithm>
+
+#include "base/sprite.hxx"
+#include <canvas/canvastoolsdllapi.h>
+
+/* Definition of SpriteRedrawManager class */
+
+namespace canvas
+{
+    /** This class manages smooth SpriteCanvas updates
+
+        Use this class to handle the ::canvas::SpriteSurface methods,
+        that track and process sprite update events. Recorded update
+        events are later grouped by connected areas (i.e. all sprites
+        that somehow overlap over a rectangular area are grouped
+        together); the forEachSpriteArea() method calls the passed
+        functor for each of those connected areas.
+
+        Note that, although this class generally works with IEEE
+        doubles, the calculation of connected areas happens in the
+        integer domain - it is generally expected that repaints can
+        only be divided at pixel boundaries, without causing visible
+        artifacts. Therefore, sprites that touch the same pixel (but
+        don't necessarily have the same floating point coordinates
+        there) will reside in a common sprite area and handled
+        together in the forEachSpriteArea functor call.
+     */
+    class CANVASTOOLS_DLLPUBLIC SpriteRedrawManager
+    {
+    public:
+        /** Data container for the connected components list
+         */
+        class SpriteInfo
+        {
+        public:
+            /** Create sprite info
+
+                @param rRef
+                Sprite this info represents (might be the NULL ref)
+
+                @param rTrueUpdateArea
+                True (un-rounded) update area this sprite has recorded
+
+                @param bNeedsUpdate
+                When false, this sprite is not a member of the change
+                record list. Thus, it only needs redraw if within the
+                update area of other, changed sprites.
+
+                @internal
+             */
+            SpriteInfo( Sprite::Reference           aRef,
+                        const ::basegfx::B2DRange&  rTrueUpdateArea,
+                        bool                        bNeedsUpdate ) :
+                mpSprite(std::move( aRef )),
+                maTrueUpdateArea( rTrueUpdateArea ),
+                mbNeedsUpdate( bNeedsUpdate ),
+                mbIsPureMove( false )
+            {
+            }
+
+            /** Create sprite info, specify move type
+
+                @param rRef
+                Sprite this info represents (might be the NULL ref)
+
+                @param rTrueUpdateArea
+                True (un-rounded) update area this sprite has recorded
+
+                @param bNeedsUpdate
+                When false, this sprite is not a member of the change
+                record list. Thus, it only needs redraw if within the
+                update area of other, changed sprites.
+
+                @param bIsPureMove
+                When true, this sprite is _only_ moved, no other
+                changes happened.
+
+                @internal
+             */
+            SpriteInfo( Sprite::Reference           aRef,
+                        const ::basegfx::B2DRange&  rTrueUpdateArea,
+                        bool                        bNeedsUpdate,
+                        bool                        bIsPureMove ) :
+                mpSprite(std::move( aRef )),
+                maTrueUpdateArea( rTrueUpdateArea ),
+                mbNeedsUpdate( bNeedsUpdate ),
+                mbIsPureMove( bIsPureMove )
+            {
+            }
+
+            const Sprite::Reference&    getSprite() const { return mpSprite; }
+
+            // #i61843# need to return by value here, to be used safely from bind
+            const ::basegfx::B2DRange&  getUpdateArea() const { return maTrueUpdateArea; }
+            bool                        needsUpdate() const { return mbNeedsUpdate; }
+            bool                        isPureMove() const { return mbIsPureMove; }
+
+        private:
+            Sprite::Reference       mpSprite;
+            ::basegfx::B2DRange     maTrueUpdateArea;
+            bool                    mbNeedsUpdate;
+            bool                    mbIsPureMove;
+        };
+
+
+        /** Helper struct for SpriteTracer template
+
+            This struct stores change information to a sprite's visual
+            appearance (move, content updated, and the like).
+         */
+        struct SpriteChangeRecord
+        {
+            enum class ChangeType { move, update };
+
+            SpriteChangeRecord( Sprite::Reference     rSprite,
+                                const ::basegfx::B2DPoint&  rOldPos,
+                                const ::basegfx::B2DPoint&  rNewPos,
+                                const ::basegfx::B2DVector& rSpriteSize ) :
+                meChangeType( ChangeType::move ),
+                mpAffectedSprite(std::move( rSprite )),
+                maOldPos( rOldPos ),
+                maUpdateArea( rNewPos.getX(),
+                              rNewPos.getY(),
+                              rNewPos.getX() + rSpriteSize.getX(),
+                              rNewPos.getY() + rSpriteSize.getY() )
+            {
+            }
+
+            SpriteChangeRecord( Sprite::Reference     rSprite,
+                                const ::basegfx::B2DPoint&  rPos,
+                                const ::basegfx::B2DRange&  rUpdateArea ) :
+                meChangeType( ChangeType::update ),
+                mpAffectedSprite(std::move( rSprite )),
+                maOldPos( rPos ),
+                maUpdateArea( rUpdateArea )
+            {
+            }
+
+            const Sprite::Reference& getSprite() const { return mpAffectedSprite; }
+
+            ChangeType          meChangeType;
+            Sprite::Reference   mpAffectedSprite;
+            ::basegfx::B2DPoint maOldPos;
+            ::basegfx::B2DRange maUpdateArea;
+        };
+
+        typedef ::std::vector< SpriteChangeRecord >             VectorOfChangeRecords;
+        typedef ::basegfx::B2DConnectedRanges< SpriteInfo >     SpriteConnectedRanges;
+        typedef SpriteConnectedRanges::ComponentType            AreaComponent;
+        typedef SpriteConnectedRanges::ConnectedComponents      UpdateArea;
+        typedef ::std::vector< Sprite::Reference >              VectorOfSprites;
+
+        SpriteRedrawManager();
+        SpriteRedrawManager(const SpriteRedrawManager&) = delete;
+        SpriteRedrawManager& operator=( const SpriteRedrawManager& ) = delete;
+
+        /** Must be called when user of this object gets
+            disposed. Frees all internal references.
+         */
+        void disposing();
+
+        /** Functor, to be used from forEachSpriteArea
+         */
+        template< typename Functor > struct AreaUpdateCaller
+        {
+            AreaUpdateCaller( Functor&                      rFunc,
+                              const SpriteRedrawManager&    rManager ) :
+                mrFunc( rFunc ),
+                mrManager( rManager )
+            {
+            }
+
+            void operator()( const UpdateArea& rUpdateArea )
+            {
+                mrManager.handleArea( mrFunc, rUpdateArea );
+            }
+
+            Functor&                    mrFunc;
+            const SpriteRedrawManager&  mrManager;
+        };
+
+        /** Call given functor for each sprite area that needs an
+            update.
+
+            This method calls the given functor for each update area
+            (calculated from the sprite change records).
+
+            @tpl Functor
+            Must provide the following four methods:
+            <pre>
+            void backgroundPaint( ::basegfx::B2DRange aUpdateRect );
+            void scrollUpdate( ::basegfx::B2DRange& o_rMoveStart,
+                               ::basegfx::B2DRange& o_rMoveEnd,
+                               UpdateArea           aUpdateArea );
+            void opaqueUpdate( const ::basegfx::B2DRange&                          rTotalArea,
+                               const ::std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites );
+            void genericUpdate( const ::basegfx::B2DRange&                          rTotalArea,
+                                const ::std::vector< ::canvas::Sprite::Reference >& rSortedUpdateSprites );
+            </pre>
+            The backgroundPaint() method is called to simply repaint
+            background content, the scrollUpdate() method is used to
+            scroll a given area, and paint background in the uncovered
+            areas, the opaqueUpdate() method is called when a sprite
+            can be painted in the given area without taking background
+            content into account, and finally, genericUpdate() is
+            called for complex updates, where first the background and
+            then all sprites consecutively have to be repainted.
+         */
+        template< typename Functor > void forEachSpriteArea( Functor& rFunc ) const
+        {
+            SpriteConnectedRanges aUpdateAreas;
+
+            setupUpdateAreas( aUpdateAreas );
+
+            aUpdateAreas.forEachAggregate(
+                AreaUpdateCaller< Functor >( rFunc, *this ) );
+        }
+
+        /** Call given functor for each active sprite.
+
+            This method calls the given functor for each active
+            sprite, in the order of sprite priority.
+
+            @tpl Functor
+            Must provide a Functor::operator( Sprite::Reference& )
+            method.
+         */
+        template< typename Functor > void forEachSprite( const Functor& rFunc ) const
+        {
+            ::std::for_each( maSprites.begin(),
+                             maSprites.end(),
+                             rFunc );
+        }
+
+        /// Clear sprite change records (typically directly after a screen update)
+        void clearChangeRecords();
+
+        // SpriteSurface interface, is delegated to e.g. from SpriteCanvas
+        void showSprite( const Sprite::Reference& rSprite );
+        void hideSprite( const Sprite::Reference& rSprite );
+        void moveSprite( const Sprite::Reference&       rSprite,
+                         const ::basegfx::B2DPoint&     rOldPos,
+                         const ::basegfx::B2DPoint&     rNewPos,
+                         const ::basegfx::B2DVector&    rSpriteSize );
+        void updateSprite( const Sprite::Reference&     rSprite,
+                           const ::basegfx::B2DPoint&   rPos,
+                           const ::basegfx::B2DRange&   rUpdateArea );
+
+        /** Internal, handles each distinct component for forEachAggregate()
+
+            The reason why this must be public is that it needs to be
+            accessible from the AreaUpdateCaller functor.
+
+            @internal
+         */
+        template< typename Functor > void handleArea( Functor&          rFunc,
+                                                      const UpdateArea& rUpdateArea ) const
+        {
+            // check whether this area contains changed sprites at all
+            // (if not, just ignore it)
+            if( !areSpritesChanged( rUpdateArea ) )
+                return;
+
+            // at least one of the sprites actually needs an
+            // update - process whole area.
+
+            // check whether this area could be handled special
+            // (background paint, direct update, scroll, etc.)
+            ::basegfx::B2DRange aMoveStart;
+            ::basegfx::B2DRange aMoveEnd;
+            if( rUpdateArea.maComponentList.empty() )
+            {
+                rFunc.backgroundPaint( rUpdateArea.maTotalBounds );
+            }
+            else
+            {
+                // cache number of sprites in this area (it's a
+                // list, and both isAreaUpdateScroll() and
+                // isAreaUpdateOpaque() need it).
+                const ::std::size_t nNumSprites(
+                    rUpdateArea.maComponentList.size() );
+
+                if( isAreaUpdateScroll( aMoveStart,
+                                        aMoveEnd,
+                                        rUpdateArea,
+                                        nNumSprites ) )
+                {
+                    rFunc.scrollUpdate( aMoveStart,
+                                        aMoveEnd,
+                                        rUpdateArea );
+                }
+                else
+                {
+                    // potentially, more than a single sprite
+                    // involved. Have to sort component lists for
+                    // sprite prio.
+                    VectorOfSprites aSortedUpdateSprites;
+                    for (auto const& elem : rUpdateArea.maComponentList)
+                    {
+                        const Sprite::Reference& rSprite( elem.second.getSprite() );
+                        if( rSprite.is() )
+                            aSortedUpdateSprites.push_back( rSprite );
+                    }
+
+                    ::std::sort( aSortedUpdateSprites.begin(),
+                                 aSortedUpdateSprites.end(),
+                                 SpriteWeakOrder() );
+
+                    if( isAreaUpdateOpaque( rUpdateArea,
+                                            nNumSprites ) )
+                    {
+                        rFunc.opaqueUpdate( rUpdateArea.maTotalBounds,
+                                            aSortedUpdateSprites );
+                    }
+                    else
+                    {
+                        rFunc.genericUpdate( rUpdateArea.maTotalBounds,
+                                             aSortedUpdateSprites );
+                    }
+                }
+            }
+        }
+
+    private:
+        /** Central method of this class. Calculates the set of
+            disjunct components that need an update.
+         */
+        void setupUpdateAreas( SpriteConnectedRanges& rUpdateAreas ) const;
+
+        bool areSpritesChanged( const UpdateArea& rUpdateArea ) const;
+
+        bool isAreaUpdateNotOpaque( const ::basegfx::B2DRectangle&  rUpdateRect,
+                                    const AreaComponent&            rComponent ) const;
+
+        bool isAreaUpdateOpaque( const UpdateArea&  rUpdateArea,
+                                 ::std::size_t      nNumSprites ) const;
+
+        /** Check whether given update area can be handled by a simple
+            scroll
+
+            @param o_rMoveStart
+            Start rect of the move
+
+            @param o_rMoveEnd
+            End rect of the move. The content must be moved from start
+            to end rect
+
+            @param rUpdateArea
+            Area to check for scroll update optimization
+         */
+        bool isAreaUpdateScroll( ::basegfx::B2DRectangle& o_rMoveStart,
+                                 ::basegfx::B2DRectangle& o_rMoveEnd,
+                                 const UpdateArea&      rUpdateArea,
+                                 ::std::size_t          nNumSprites ) const;
+
+
+        VectorOfSprites                 maSprites; // list of active
+                                                   // sprite
+                                                   // objects. this
+                                                   // list is only
+                                                   // used for full
+                                                   // repaints,
+                                                   // otherwise, we
+                                                   // rely on the
+                                                   // active sprites
+                                                   // itself to notify
+                                                   // us.
+
+        VectorOfChangeRecords           maChangeRecords; // vector of
+                                                         // sprites
+                                                         // changes
+                                                         // since last
+                                                         // updateScreen()
+                                                         // call
+    };
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */