tools.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 .
 */
 
#ifndef INCLUDED_SLIDESHOW_SOURCE_INC_TOOLS_HXX
#define INCLUDED_SLIDESHOW_SOURCE_INC_TOOLS_HXX
 
#include <com/sun/star/uno/Sequence.hxx>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/uno/Reference.hxx>
#include <com/sun/star/animations/XAnimationNode.hpp>
#include <com/sun/star/container/XEnumerationAccess.hpp>
#include <com/sun/star/container/XEnumeration.hpp>
#include <comphelper/random.hxx>
#include <sal/log.hxx>
 
#include <cppcanvas/color.hxx>
 
#include "shapeattributelayer.hxx"
#include "shape.hxx"
#include "rgbcolor.hxx"
#include "hslcolor.hxx"
 
#include <memory>
 
namespace com::sun::star::beans { struct NamedValue; }
namespace basegfx
{
    class B2DRange;
    class B2DVector;
    class B2IVector;
    class B2DHomMatrix;
    class B2ISize;
}
namespace cppcanvas{ class Canvas; }
 
class GDIMetaFile;
 
/* Definition of some animation tools */
namespace slideshow
{
    namespace internal
    {
        class UnoView;
        class Shape;
        class ShapeAttributeLayer;
        typedef std::shared_ptr< UnoView > UnoViewSharedPtr;
        typedef std::shared_ptr< GDIMetaFile > GDIMetaFileSharedPtr;
 
        template <typename T>
        inline ::std::size_t hash_value( T const * p )
        {
            ::std::size_t d = static_cast< ::std::size_t >(
                reinterpret_cast< ::std::ptrdiff_t >(p) );
            return d + (d >> 3);
        }
 
        template <typename T>
        struct hash
        {
            ::std::size_t operator()( T const& val ) const {
                return hash_value(val);
            }
        };
    }
}
 
namespace com::sun::star::uno {
 
        template <typename T>
        inline ::std::size_t hash_value(
            css::uno::Reference<T> const& x )
        {
            // normalize to object root, because _only_ XInterface is defined
            // to be stable during object lifetime:
            css::uno::Reference< css::uno::XInterface> const xRoot( x, css::uno::UNO_QUERY );
            return slideshow::internal::hash<void *>()(xRoot.get());
        }
 
}
 
namespace slideshow
{
    namespace internal
    {
        // Value extraction from Any
        // =========================
 
        bool extractValue( double&                              o_rValue,
                           const css::uno::Any&                rSourceAny,
                           const ShapeSharedPtr&                rShape,
                           const basegfx::B2DVector&            rSlideBounds );
 
        bool extractValue( sal_Int32&                           o_rValue,
                           const css::uno::Any&                 rSourceAny,
                           const ShapeSharedPtr&                rShape,
                           const basegfx::B2DVector&            rSlideBounds );
 
        bool extractValue( sal_Int16&                           o_rValue,
                           const css::uno::Any&                 rSourceAny,
                           const ShapeSharedPtr&                rShape,
                           const basegfx::B2DVector&            rSlideBounds );
 
        bool extractValue( RGBColor&                            o_rValue,
                           const css::uno::Any&                 rSourceAny,
                           const ShapeSharedPtr&                rShape,
                           const basegfx::B2DVector&            rSlideBounds );
 
        bool extractValue( HSLColor&                            o_rValue,
                           const css::uno::Any&                 rSourceAny,
                           const ShapeSharedPtr&                rShape,
                           const basegfx::B2DVector&            rSlideBounds );
 
        bool extractValue( OUString&                            o_rValue,
                           const css::uno::Any&                 rSourceAny,
                           const ShapeSharedPtr&                rShape,
                           const basegfx::B2DVector&            rSlideBounds );
 
        bool extractValue( bool&                                o_rValue,
                           const css::uno::Any&    rSourceAny,
                           const ShapeSharedPtr&                rShape,
                           const basegfx::B2DVector&            rSlideBounds );
 
        bool extractValue( basegfx::B2DTuple&                   o_rPair,
                           const css::uno::Any&                 rSourceAny,
                           const ShapeSharedPtr&                rShape,
                           const basegfx::B2DVector&            rSlideBounds );
 
        bool findNamedValue( css::uno::Sequence< css::beans::NamedValue > const& rSequence,
                             const css::beans::NamedValue& rSearchKey );
 
        basegfx::B2DRange calcRelativeShapeBounds( const basegfx::B2DVector& rPageSize,
                                                   const basegfx::B2DRange&  rShapeBounds );
 
        basegfx::B2DHomMatrix getShapeTransformation(
            const basegfx::B2DRectangle&         rBounds,
            const ShapeAttributeLayerSharedPtr&  pAttr );
 
        basegfx::B2DHomMatrix getSpriteTransformation(
            const basegfx::B2DVector&           rPixelSize,
            const basegfx::B2DVector&           rOrigSize,
            const ShapeAttributeLayerSharedPtr& pAttr );
 
        basegfx::B2DRectangle getShapeUpdateArea(
            const basegfx::B2DRectangle&          rUnitBounds,
            const basegfx::B2DHomMatrix&          rShapeTransform,
            const ShapeAttributeLayerSharedPtr&   pAttr );
 
        basegfx::B2DRange getShapeUpdateArea( const basegfx::B2DRange& rUnitBounds,
                                              const basegfx::B2DRange& rShapeBounds );
 
        basegfx::B2DRectangle getShapePosSize(
            const basegfx::B2DRectangle&        rOrigBounds,
            const ShapeAttributeLayerSharedPtr& pAttr );
 
        RGBColor unoColor2RGBColor( sal_Int32 );
        sal_Int32 RGBAColor2UnoColor( cppcanvas::IntSRGBA );
 
        void fillRect( const cppcanvas::CanvasSharedPtr&       rCanvas,
                       const basegfx::B2DRectangle& rRect,
                       cppcanvas::IntSRGBA          aFillColor );
 
        void initSlideBackground( const cppcanvas::CanvasSharedPtr&    rCanvas,
                                  const basegfx::B2ISize&   rSize );
 
        inline ::std::size_t getRandomOrdinal( const ::std::size_t n )
        {
            return comphelper::rng::uniform_size_distribution(0, n-1);
        }
 
        template <typename ValueType>
        inline bool getPropertyValue(
            ValueType & rValue,
            css::uno::Reference<
            css::beans::XPropertySet> const & xPropSet,
            OUString const & propName )
        {
            try {
                const css::uno::Any& a(
                    xPropSet->getPropertyValue( propName ) );
                bool const bRet = css::uno::fromAny(a, &rValue);
#if OSL_DEBUG_LEVEL > 0
                if( !bRet )
                    SAL_INFO("slideshow", __func__ << ": while retrieving property " << propName << ", cannot extract Any of type "
                               << a.getValueTypeRef()->pTypeName);
#endif
                return bRet;
            }
            catch (css::uno::RuntimeException &)
            {
                throw;
            }
            catch (css::uno::Exception &)
            {
                return false;
            }
        }
 
        template <typename ValueType>
        inline bool getPropertyValue(
            css::uno::Reference< ValueType >& rIfc,
            css::uno::Reference< css::beans::XPropertySet> const & xPropSet,
            OUString const & propName )
        {
            try
            {
                const css::uno::Any& a(xPropSet->getPropertyValue( propName ));
                rIfc.set( a, css::uno::UNO_QUERY );
 
                bool const bRet = rIfc.is();
#if OSL_DEBUG_LEVEL > 0
                if( !bRet )
                    SAL_INFO("slideshow", __func__ << ": while retrieving property " << propName << ", cannot extract Any of type "
                               << a.getValueTypeRef()->pTypeName << " to interface");
#endif
                return bRet;
            }
            catch (css::uno::RuntimeException &)
            {
                throw;
            }
            catch (css::uno::Exception &)
            {
                return false;
            }
        }
 
        basegfx::B2DRectangle getAPIShapeBounds( const css::uno::Reference< css::drawing::XShape >& xShape );
 
/*
        TODO(F1): When ZOrder someday becomes usable enable this
 
        double getAPIShapePrio( const css::uno::Reference< css::drawing::XShape >& xShape );
*/
 
        basegfx::B2IVector getSlideSizePixel( const basegfx::B2DVector&  rSize,
                                              const UnoViewSharedPtr&    pView );
    }
 
    // TODO(Q1): this could possibly be implemented with a somewhat
    // more lightweight template, by having the actual worker receive
    // only a function pointer, and a thin templated wrapper around
    // that which converts member functions into that.
 
    template< typename Functor > inline bool for_each_childNode( const css::uno::Reference< css::animations::XAnimationNode >&    xNode,
                                                                 Functor&                                                                                  rFunctor )
    {
        try
        {
            // get an XEnumerationAccess to the children
            css::uno::Reference< css::container::XEnumerationAccess >
                   xEnumerationAccess( xNode,
                                       css::uno::UNO_QUERY_THROW );
            css::uno::Reference< css::container::XEnumeration >
                   xEnumeration( xEnumerationAccess->createEnumeration(),
                                 css::uno::UNO_SET_THROW );
 
            while( xEnumeration->hasMoreElements() )
            {
                css::uno::Reference< css::animations::XAnimationNode >
                           xChildNode( xEnumeration->nextElement(),
                                      css::uno::UNO_QUERY_THROW );
                rFunctor( xChildNode );
            }
            return true;
        }
        catch( css::uno::Exception& )
        {
            return false;
        }
    }
}
 
#endif // INCLUDED_SLIDESHOW_SOURCE_INC_TOOLS_HXX
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */