slideshow/source/inc/tools.hxx

   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 #ifndef INCLUDED_SLIDESHOW_SOURCE_INC_TOOLS_HXX
  21 #define INCLUDED_SLIDESHOW_SOURCE_INC_TOOLS_HXX
  22
  23 #include <com/sun/star/uno/Sequence.hxx>
  24 #include <com/sun/star/beans/XPropertySet.hpp>
  25 #include <com/sun/star/uno/Reference.hxx>
  26 #include <com/sun/star/animations/XAnimationNode.hpp>
  27 #include <com/sun/star/container/XEnumerationAccess.hpp>
  28 #include <com/sun/star/container/XEnumeration.hpp>
  29 #include <comphelper/random.hxx>
  30 #include <osl/diagnose.h>
  31 #include <vector>
  32
  33 #include <cppcanvas/color.hxx>
  34
  35 #include "shapeattributelayer.hxx"
  36 #include "shape.hxx"
  37 #include "rgbcolor.hxx"
  38 #include "hslcolor.hxx"
  39
  40 #include <memory>
  41 #include <cstdlib>
  42 #include <string.h>
  43 #include <algorithm>
  44
  45 namespace com { namespace sun { namespace star { namespace beans {
  46     struct NamedValue;
  47 } } } }
  48 namespace basegfx
  49 {
  50     class B2DRange;
  51     class B2DVector;
  52     class B2IVector;
  53     class B2DHomMatrix;
  54 }
  55 namespace cppcanvas{ class Canvas; }
  56
  57 class GDIMetaFile;
  58
  59 /* Definition of some animation tools */
  60 namespace slideshow
  61 {
  62     namespace internal
  63     {
  64         class UnoView;
  65         class Shape;
  66         class ShapeAttributeLayer;
  67
  68         typedef ::std::shared_ptr< GDIMetaFile > GDIMetaFileSharedPtr;
  69
  70         template <typename T>
  71         inline ::std::size_t hash_value( T const * p )
  72         {
  73             ::std::size_t d = static_cast< ::std::size_t >(
  74                 reinterpret_cast< ::std::ptrdiff_t >(p) );
  75             return d + (d >> 3);
  76         }
  77
  78         // xxx todo: remove with boost::hash when 1.33 is available
  79         template <typename T>
  80         struct hash
  81         {
  82             ::std::size_t operator()( T const& val ) const {
  83                 return hash_value(val);
  84             }
  85         };
  86     }
  87 }
  88
  89 namespace com { namespace sun { namespace star { namespace uno {
  90
  91         template <typename T>
  92         inline ::std::size_t hash_value(
  93             css::uno::Reference<T> const& x )
  94         {
  95             // normalize to object root, because _only_ XInterface is defined
  96             // to be stable during object lifetime:
  97             css::uno::Reference< css::uno::XInterface> const xRoot( x, css::uno::UNO_QUERY );
  98             return slideshow::internal::hash<void *>()(xRoot.get());
  99         }
 100
 101 } } } }
 102
 103 namespace slideshow
 104 {
 105     namespace internal
 106     {
 107         // Value extraction from Any
 108         // =========================
 109
 110         /// extract unary double value from Any
 111         bool extractValue( double&                              o_rValue,
 112                            const css::uno::Any&                rSourceAny,
 113                            const std::shared_ptr<Shape>&      rShape,
 114                            const basegfx::B2DVector&            rSlideBounds );
 115
 116         /// extract int from Any
 117         bool extractValue( sal_Int32&                           o_rValue,
 118                            const css::uno::Any&                 rSourceAny,
 119                            const std::shared_ptr<Shape>&      rShape,
 120                            const basegfx::B2DVector&            rSlideBounds );
 121
 122         /// extract enum/constant group value from Any
 123         bool extractValue( sal_Int16&                           o_rValue,
 124                            const css::uno::Any&                 rSourceAny,
 125                            const std::shared_ptr<Shape>&      rShape,
 126                            const basegfx::B2DVector&            rSlideBounds );
 127
 128         /// extract color value from Any
 129         bool extractValue( RGBColor&                            o_rValue,
 130                            const css::uno::Any&                 rSourceAny,
 131                            const std::shared_ptr<Shape>&      rShape,
 132                            const basegfx::B2DVector&            rSlideBounds );
 133
 134         /// extract color value from Any
 135         bool extractValue( HSLColor&                            o_rValue,
 136                            const css::uno::Any&                 rSourceAny,
 137                            const std::shared_ptr<Shape>&      rShape,
 138                            const basegfx::B2DVector&            rSlideBounds );
 139
 140         /// extract plain string from Any
 141         bool extractValue( OUString&                            o_rValue,
 142                            const css::uno::Any&                 rSourceAny,
 143                            const std::shared_ptr<Shape>&      rShape,
 144                            const basegfx::B2DVector&            rSlideBounds );
 145
 146         /// extract bool value from Any
 147         bool extractValue( bool&                                o_rValue,
 148                            const css::uno::Any&    rSourceAny,
 149                            const std::shared_ptr<Shape>&      rShape,
 150                            const basegfx::B2DVector&            rSlideBounds );
 151
 152         /// extract double 2-tuple from Any
 153         bool extractValue( basegfx::B2DTuple&                   o_rPair,
 154                            const css::uno::Any&                 rSourceAny,
 155                            const std::shared_ptr<Shape>&      rShape,
 156                            const basegfx::B2DVector&            rSlideBounds );
 157
 158         /** Search a sequence of NamedValues for a given element.
 159
 160             @return true, if the sequence contains the specified
 161             element.
 162          */
 163         bool findNamedValue( css::uno::Sequence< css::beans::NamedValue > const& rSequence,
 164                              const css::beans::NamedValue& rSearchKey );
 165
 166         basegfx::B2DRange calcRelativeShapeBounds( const basegfx::B2DVector& rPageSize,
 167                                                    const basegfx::B2DRange&  rShapeBounds );
 168
 169         /** Get the shape transformation from the attribute set
 170
 171             @param rBounds
 172             Original shape bound rect (to substitute default attribute
 173             layer values)
 174
 175             @param pAttr
 176             Attribute set. Might be NULL (then, rBounds is used to set
 177             a simple scale and translate of the unit rect to rBounds).
 178         */
 179         basegfx::B2DHomMatrix getShapeTransformation(
 180             const basegfx::B2DRange&                      rBounds,
 181             const std::shared_ptr<ShapeAttributeLayer>& pAttr );
 182
 183         /** Get a shape's sprite transformation from the attribute set
 184
 185             @param rPixelSize
 186             Pixel size of the sprite
 187
 188             @param rOrigSize
 189             Original shape size (i.e. the size of the actual sprite
 190             content, in the user coordinate system)
 191
 192             @param pAttr
 193             Attribute set. Might be NULL (then, rBounds is used to set
 194             a simple scale and translate of the unit rect to rBounds).
 195
 196             @return the transformation to be applied to the sprite.
 197         */
 198         basegfx::B2DHomMatrix getSpriteTransformation(
 199             const basegfx::B2DVector&                     rPixelSize,
 200             const basegfx::B2DVector&                     rOrigSize,
 201             const std::shared_ptr<ShapeAttributeLayer>& pAttr );
 202
 203         /** Calc update area for a shape.
 204
 205             This method calculates the 'covered' area for the shape,
 206             i.e. the rectangle that is affected when rendering the
 207             shape. Apart from applying the given transformation to the
 208             shape rectangle, this method also takes attributes into
 209             account, which further scale the output (e.g. character
 210             sizes).
 211
 212             @param rUnitBounds
 213             Shape bounds, in the unit rect coordinate space
 214
 215             @param rShapeTransform
 216             Transformation matrix the shape should undergo.
 217
 218             @param pAttr
 219             Current shape attributes
 220          */
 221         basegfx::B2DRange getShapeUpdateArea(
 222             const basegfx::B2DRange&                      rUnitBounds,
 223             const basegfx::B2DHomMatrix&                  rShapeTransform,
 224             const std::shared_ptr<ShapeAttributeLayer>& pAttr );
 225
 226         /** Calc update area for a shape.
 227
 228             This method calculates the 'covered' area for the shape,
 229             i.e. the rectangle that is affected when rendering the
 230             shape. The difference from the other getShapeUpdateArea()
 231             method is the fact that this one works without
 232             ShapeAttributeLayer, and only scales up the given shape
 233             user coordinate bound rect. The method is typically used
 234             to retrieve user coordinate system bound rects for shapes
 235             which are smaller than the default unit bound rect
 236             (because e.g. of subsetting)
 237
 238             @param rUnitBounds
 239             Shape bounds, in the unit rect coordinate space
 240
 241             @param rShapeBounds
 242             Current shape bounding box in user coordinate space.
 243          */
 244         basegfx::B2DRange getShapeUpdateArea( const basegfx::B2DRange& rUnitBounds,
 245                                               const basegfx::B2DRange& rShapeBounds );
 246
 247         /** Calc output position and size of shape, according to given
 248             attribute layer.
 249
 250             Rotations, shears etc. and not taken into account,
 251             i.e. the returned rectangle is NOT the bounding box. Use
 252             it as if aBounds.getMinimum() is the output position and
 253             aBounds.getRange() the scaling of the shape.
 254          */
 255         basegfx::B2DRange getShapePosSize(
 256             const basegfx::B2DRange&                      rOrigBounds,
 257             const std::shared_ptr<ShapeAttributeLayer>& pAttr );
 258
 259         /** Convert a plain UNO API 32 bit int to RGBColor
 260          */
 261         RGBColor unoColor2RGBColor( sal_Int32 );
 262         /** Convert an IntSRGBA to plain UNO API 32 bit int
 263          */
 264         sal_Int32 RGBAColor2UnoColor( cppcanvas::IntSRGBA );
 265
 266         /** Fill a plain rectangle on the given canvas with the given color
 267          */
 268         void fillRect( const std::shared_ptr< cppcanvas::Canvas >& rCanvas,
 269                        const basegfx::B2DRange&                      rRect,
 270                        cppcanvas::IntSRGBA                    aFillColor );
 271
 272         /** Init canvas with default background (white)
 273          */
 274         void initSlideBackground( const std::shared_ptr< cppcanvas::Canvas >& rCanvas,
 275                                   const basegfx::B2IVector&                     rSize );
 276
 277         /// Gets a random ordinal [0,n)
 278         inline ::std::size_t getRandomOrdinal( const ::std::size_t n )
 279         {
 280             return comphelper::rng::uniform_size_distribution(0, n-1);
 281         }
 282
 283         template <typename ValueType>
 284         inline bool getPropertyValue(
 285             ValueType & rValue,
 286             css::uno::Reference<
 287             css::beans::XPropertySet> const & xPropSet,
 288             OUString const & propName )
 289         {
 290             try {
 291                 const css::uno::Any& a(
 292                     xPropSet->getPropertyValue( propName ) );
 293                 bool const bRet = css::uno::fromAny(a, &rValue);
 294 #if OSL_DEBUG_LEVEL > 0
 295                 if( !bRet )
 296                     SAL_INFO("slideshow", OSL_THIS_FUNC << ": while retrieving property " << propName << ", cannot extract Any of type "
 297                                << a.getValueTypeRef()->pTypeName);
 298 #endif
 299                 return bRet;
 300             }
 301             catch (css::uno::RuntimeException &)
 302             {
 303                 throw;
 304             }
 305             catch (css::uno::Exception &)
 306             {
 307                 return false;
 308             }
 309         }
 310
 311         template <typename ValueType>
 312         inline bool getPropertyValue(
 313             css::uno::Reference< ValueType >& rIfc,
 314             css::uno::Reference< css::beans::XPropertySet> const & xPropSet,
 315             OUString const & propName )
 316         {
 317             try
 318             {
 319                 const css::uno::Any& a(xPropSet->getPropertyValue( propName ));
 320                 rIfc.set( a, css::uno::UNO_QUERY );
 321
 322                 bool const bRet = rIfc.is();
 323 #if OSL_DEBUG_LEVEL > 0
 324                 if( !bRet )
 325                     SAL_INFO("slideshow", OSL_THIS_FUNC << ": while retrieving property " << propName << ", cannot extract Any of type "
 326                                << a.getValueTypeRef()->pTypeName << " to interface");
 327 #endif
 328                 return bRet;
 329             }
 330             catch (css::uno::RuntimeException &)
 331             {
 332                 throw;
 333             }
 334             catch (css::uno::Exception &)
 335             {
 336                 return false;
 337             }
 338         }
 339
 340         /// Get the content of the BoundRect shape property
 341         basegfx::B2DRange getAPIShapeBounds( const css::uno::Reference< css::drawing::XShape >& xShape );
 342
 343 /*
 344         TODO(F1): When ZOrder someday becomes usable enable this
 345
 346         /// Get the content of the ZOrder shape property
 347         double getAPIShapePrio( const css::uno::Reference< css::drawing::XShape >& xShape );
 348 */
 349
 350         basegfx::B2IVector getSlideSizePixel( const basegfx::B2DVector&         rSize,
 351                                               const std::shared_ptr<UnoView>& pView );
 352     }
 353
 354     // TODO(Q1): this could possibly be implemented with a somewhat
 355     // more lightweight template, by having the actual worker receive
 356     // only a function pointer, and a thin templated wrapper around
 357     // that which converts member functions into that.
 358
 359     /** Apply given functor to every animation node child.
 360
 361         @param xNode
 362         Parent node
 363
 364         @param rFunctor
 365         Functor to apply. The functor must have an appropriate
 366         operator()( const css::uno::Reference< css::animations::XAnimationNode >& ) member.
 367
 368         @return true, if the functor was successfully applied to
 369         all children, false otherwise.
 370     */
 371     template< typename Functor > inline bool for_each_childNode( const css::uno::Reference< css::animations::XAnimationNode >&    xNode,
 372                                                                  Functor&                                                                                  rFunctor )
 373     {
 374         try
 375         {
 376             // get an XEnumerationAccess to the children
 377             css::uno::Reference< css::container::XEnumerationAccess >
 378                    xEnumerationAccess( xNode,
 379                                        css::uno::UNO_QUERY_THROW );
 380             css::uno::Reference< css::container::XEnumeration >
 381                    xEnumeration( xEnumerationAccess->createEnumeration(),
 382                                  css::uno::UNO_QUERY_THROW );
 383
 384             while( xEnumeration->hasMoreElements() )
 385             {
 386                 css::uno::Reference< css::animations::XAnimationNode >
 387                            xChildNode( xEnumeration->nextElement(),
 388                                       css::uno::UNO_QUERY_THROW );
 389                 rFunctor( xChildNode );
 390             }
 391                                                                                                                                                                                                                            return true;
 392         }
 393         catch( css::uno::Exception& )
 394         {
 395             return false;
 396         }
 397     }
 398 }
 399
 400 #endif // INCLUDED_SLIDESHOW_SOURCE_INC_TOOLS_HXX
 401
 402 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */